<bit>
funzioni
L'intestazione <bit>
include le funzioni del modello non membro seguenti:
Funzioni non membro | Descrizione |
---|---|
bit_cast |
Reinterpretare la rappresentazione dell'oggetto da un tipo a un altro. |
bit_ceil |
Trovare la potenza più piccola di due maggiore o uguale a un valore. |
bit_floor |
Trovare la potenza massima di due non maggiore di un valore. |
bit_width |
Trovare il numero minimo di bit necessari per rappresentare un valore. |
countl_zero |
Contare il numero di bit consecutivi impostati su zero, a partire dal bit più significativo. |
countl_one |
Contare il numero di bit consecutivi impostati su uno, a partire dal bit più significativo. |
countr_zero |
Contare il numero di bit consecutivi impostati su zero, a partire dal bit meno significativo. |
countr_one |
Contare il numero di bit consecutivi impostati su uno, a partire dal bit meno significativo. |
has_single_bit |
Controllare se un valore ha un solo bit impostato su uno. Si tratta dello stesso tipo di test che indica se un valore è una potenza di due. |
popcount |
Contare il numero di bit impostati su uno. |
rotl |
Calcolare il risultato di una rotazione a sinistra bit per bit. |
rotr |
Calcolare il risultato di una rotazione a destra bit per bit. |
Copiare un modello di bit da un oggetto di tipo From
a un nuovo oggetto di tipo To
.
template <class To, class From>
[[nodiscard]] constexpr To bit_cast(const From& from) noexcept;
Per
Tipo dell'output.
Da
Tipo del valore da convertire.
da
Valore da convertire.
Oggetto di tipo To
.
Ogni bit nel risultato corrisponde al bit corrispondente in, from
a meno che non siano presenti bit di spaziatura interna in To
, nel qual caso tali bit nel risultato non sono specificati.
#include <bit>
#include <iostream>
int main()
{
float f = std::numeric_limits<float>::infinity();
int i = std::bit_cast<int>(f);
std::cout << "float f = " << std::hex << f
<< "\nstd::bit_cast<int>(f) = " << std::hex << i << '\n';
return 0;
}
float f = inf
std::bit_cast<int>(f) = 7f800000
Il codice di basso livello spesso deve interpretare un oggetto di un tipo come un altro tipo. L'oggetto reinterpretato ha la stessa rappresentazione bit dell'originale, ma è un tipo diverso.
Anziché usare reinterpret_cast
, o memcpy()
, bit_cast()
è un modo migliore per eseguire queste conversioni. È meglio perché:
bit_cast()
èconstexpr
bit_cast()
richiede che i tipi siano facilmente copiabili e le stesse dimensioni. In questo modo si evitano potenziali problemi che è possibile riscontrare usandoreinterpret_cast
ememcpy
perché potrebbero essere usati per inavvertitamente, e in modo non corretto, convertire tipi non copiabili non banalmente.memcpy()
Può anche essere usato per copiare inavvertitamente tra tipi che non sono le stesse dimensioni. Ad esempio, un doppio (8 byte) in un int senza segno (4 byte) o in altro modo.
Questo overload partecipa alla risoluzione dell'overload solo se:
sizeof(To) == sizeof(From)
To
eFrom
sono is_trivially_copyable.
Questo modello di funzione è constexpr
se e solo se To
, From
e i tipi dei relativi oggetti secondari sono:
- Non un tipo di unione o puntatore
- Non un puntatore al tipo di membro
- Non qualificato da volatile
- Nessun membro dati non statico che sia un tipo riferimento
Trovare la potenza più piccola di due maggiore o uguale a un valore. Ad esempio, dato 3
, restituisce 4
.
template<class T>
[[nodiscard]] constexpr T bit_ceil(T value);
value
Valore intero senza segno da testare.
La potenza più piccola di due maggiore o uguale a value
.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
for (auto i = 0u; i < 6u; ++i) // bit_ceil() takes an unsigned integer type
{
auto nextClosestPowerOf2 = std::bit_ceil(i);
std::cout << "\nbit_ceil(0b" << std::bitset<4>(i) << ") = "
<< "0b" << std::bitset<4>(nextClosestPowerOf2);
}
return 0;
}
bit_ceil(0b0000) = 0b0001
bit_ceil(0b0001) = 0b0001
bit_ceil(0b0010) = 0b0010
bit_ceil(0b0011) = 0b0100
bit_ceil(0b0100) = 0b0100
bit_ceil(0b0101) = 0b1000
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Trovare la potenza massima di due non maggiore di un valore. Ad esempio, dato 5
, restituisce 4
.
template< class T >
[[nodiscard]] constexpr T bit_floor(T value) noexcept;
value
Valore intero senza segno da testare.
La potenza più grande di due che non è maggiore di value
.
Se value
è zero, restituisce zero.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
for (auto i = 0u; i < 6u; ++i) // bit_floor() takes an unsigned integer type
{
auto previousPowerOf2 = std::bit_floor(i);
std::cout << "\nbit_floor(0b" << std::bitset<4>(i) << ") = 0b"
<< std::bitset<4>(previousPowerOf2);
}
return 0;
}
bit_floor(0b0000) = 0b0000
bit_floor(0b0001) = 0b0001
bit_floor(0b0010) = 0b0010
bit_floor(0b0011) = 0b0010
bit_floor(0b0100) = 0b0100
bit_floor(0b0101) = 0b0100
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Trovare il numero minimo di bit necessari per rappresentare un valore.
Ad esempio, dato 5 (0b101), restituisce 3 perché accetta 3 bit binari per esprimere il valore 5.
template<class T>
[[nodiscard]] constexpr T bit_width(T value) noexcept;
value
Valore intero senza segno da testare.
Numero di bit necessari per rappresentare value
.
Se value
è zero, restituisce zero.
#include <bit>
#include <iostream>
int main()
{
for (unsigned i=0u; i <= 8u; ++i)
{
std::cout << "\nbit_width(" << i << ") = "
<< std::bit_width(i);
}
return 0;
}
bit_width(0) = 0
bit_width(1) = 1
bit_width(2) = 2
bit_width(3) = 2
bit_width(4) = 3
bit_width(5) = 3
bit_width(6) = 3
bit_width(7) = 3
bit_width(8) = 4
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Contare il numero di bit consecutivi impostati su zero, a partire dal bit più significativo.
template<class T>
[[nodiscard]] constexpr int countl_zero(T value) noexcept;
value
Valore intero senza segno da testare.
Numero di bit zero consecutivi, a partire dal bit più significativo.
Se value
è zero, il numero di bit nel tipo di value
.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
for (unsigned char result = 0, i = 0; i < 9; i++)
{
std::cout << "\ncountl_zero(0b" << std::bitset<8>(result) << ") = " << std::countl_zero(result);
result = result == 0 ? 1 : result * 2;
}
return 0;
}
countl_zero(0b00000000) = 8
countl_zero(0b00000001) = 7
countl_zero(0b00000010) = 6
countl_zero(0b00000100) = 5
countl_zero(0b00001000) = 4
countl_zero(0b00010000) = 3
countl_zero(0b00100000) = 2
countl_zero(0b01000000) = 1
countl_zero(0b10000000) = 0
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Contare il numero di bit consecutivi impostati su uno, a partire dal bit più significativo.
template<class T>
[[nodiscard]] constexpr int countl_one(T value) noexcept;
value
Valore intero senza segno da testare.
Numero di bit consecutivi impostati su uno, a partire dal bit più significativo.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
unsigned char value = 0;
for (unsigned char bit = 128; bit > 0; bit /= 2)
{
value |= bit;
std::cout << "\ncountl_one(0b" << std::bitset<8>(value) << ") = "
<< std::countl_one(value);
}
return 0;
}
countl_one(0b10000000) = 1
countl_one(0b11000000) = 2
countl_one(0b11100000) = 3
countl_one(0b11110000) = 4
countl_one(0b11111000) = 5
countl_one(0b11111100) = 6
countl_one(0b11111110) = 7
countl_one(0b11111111) = 8
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Contare il numero di bit consecutivi impostati su zero, a partire dal bit meno significativo.
template<class T>
[[nodiscard]] constexpr int countr_zero(T value) noexcept;
value
Valore intero senza segno da testare.
Numero di bit zero consecutivi, a partire dal bit meno significativo.
Se value
è zero, il numero di bit nel tipo di value
.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
for (unsigned char result = 0, i = 0; i < 9; i++)
{
std::cout << "\ncountr_zero(0b" << std::bitset<8>(result) << ") = "
<< std::countr_zero(result);
result = result == 0 ? 1 : result * 2;
}
return 0;
}
countr_zero(0b00000000) = 8
countr_zero(0b00000001) = 0
countr_zero(0b00000010) = 1
countr_zero(0b00000100) = 2
countr_zero(0b00001000) = 3
countr_zero(0b00010000) = 4
countr_zero(0b00100000) = 5
countr_zero(0b01000000) = 6
countr_zero(0b10000000) = 7
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Contare il numero di bit consecutivi impostati su uno, a partire dal bit meno significativo.
template<class T>
[[nodiscard]] constexpr int countr_one(T value) noexcept;
value
Valore intero senza segno da testare.
Numero di bit consecutivi impostati su uno, a partire dal bit meno significativo.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
unsigned char value = 0;
for (int bit = 1; bit <= 128; bit *= 2)
{
value |= bit;
std::cout << "\ncountr_one(0b" << std::bitset<8>(value) << ") = "
<< std::countr_one(value);
}
return 0;
}
countr_one(0b00000001) = 1
countr_one(0b00000011) = 2
countr_one(0b00000111) = 3
countr_one(0b00001111) = 4
countr_one(0b00011111) = 5
countr_one(0b00111111) = 6
countr_one(0b01111111) = 7
countr_one(0b11111111) = 8
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Controllare se un valore ha un solo bit impostato. Si tratta dello stesso tipo di test che indica se un valore è una potenza di due.
template <class T>
[[nodiscard]] constexpr bool has_single_bit(T value) noexcept;
value
Valore intero senza segno da testare.
true
se value
ha un solo bit impostato, il che significa anche che value
è una potenza di due. In caso contrario, false
.
#include <bit>
#include <bitset>
#include <iostream>
#include <iomanip>
int main()
{
for (auto i = 0u; i < 10u; ++i)
{
std::cout << "has_single_bit(0b" << std::bitset<4>(i) << ") = "
<< std::boolalpha << std::has_single_bit(i) << '\n';
}
return 0;
}
has_single_bit(0b0000) = false
has_single_bit(0b0001) = true
has_single_bit(0b0010) = true
has_single_bit(0b0011) = false
has_single_bit(0b0100) = true
has_single_bit(0b0101) = false
has_single_bit(0b0110) = false
has_single_bit(0b0111) = false
has_single_bit(0b1000) = true
has_single_bit(0b1001) = false
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Contare il numero di bit impostati su uno in un valore intero senza segno.
template<class T>
[[nodiscard]] constexpr int popcount(T value) noexcept;
value
Valore intero senza segno da testare.
I bit numerici impostati su uno in value
.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
for (unsigned char value = 0; value < 16; value++)
{
std::cout << "\npopcount(0b" << std::bitset<4>(value) << ") = "
<< std::popcount(value);
}
return 0;
}
popcount(0b0000) = 0
popcount(0b0001) = 1
popcount(0b0010) = 1
popcount(0b0011) = 2
popcount(0b0100) = 1
popcount(0b0101) = 2
popcount(0b0110) = 2
popcount(0b0111) = 3
popcount(0b1000) = 1
popcount(0b1001) = 2
popcount(0b1010) = 2
popcount(0b1011) = 3
popcount(0b1100) = 2
popcount(0b1101) = 3
popcount(0b1110) = 3
popcount(0b1111) = 4
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Ruota i bit di un valore intero senza segno a sinistra del numero di volte specificato. I bit che "cadono" del bit più a sinistra vengono ruotati nel bit più a destra.
template<class T>
[[nodiscard]] constexpr T rotl(T value, int s) noexcept;
value
Valore intero senza segno da ruotare.
s
Numero di rotazioni a sinistra da eseguire.
Risultato della rotazione value
a sinistra, s
volte.
Se s
è zero, restituisce value
.
Se s
è negativo, esegue rotr(value, -s)
. I bit che "cadono" del bit più a destra vengono ruotati nel bit più a sinistra.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
unsigned char bits = 1;
for (int i = 0; i < 8; ++i)
{
std::cout << "rotl(0b" << std::bitset<8>(bits) << ", 1) = ";
bits = std::rotl(bits, 1);
std::cout << "0b" << std::bitset<8>(bits) << '\n';
}
std::cout << "rotl(0b" << std::bitset<8>(bits) << ",-1) = ";
bits = std::rotl(bits, -1);
std::cout << "0b" << std::bitset<8>(bits);
return 0;
}
rotl(0b00000001, 1) = 0b00000010
rotl(0b00000010, 1) = 0b00000100
rotl(0b00000100, 1) = 0b00001000
rotl(0b00001000, 1) = 0b00010000
rotl(0b00010000, 1) = 0b00100000
rotl(0b00100000, 1) = 0b01000000
rotl(0b01000000, 1) = 0b10000000
rotl(0b10000000, 1) = 0b00000001
rotl(0b00000001,-1) = 0b10000000
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Ruota i bit di value
destra il numero di volte specificato. I bit che "cadono" del bit più a destra vengono ruotati di nuovo nel bit più a sinistra.
template<class T>
[[nodiscard]] constexpr T rotr(T value, int s) noexcept;
value
Valore intero senza segno da ruotare.
s
Numero di rotazioni a destra da eseguire.
Risultato della rotazione value
a destra, s
tempi.
Se s
è zero, restituisce value
.
Se s
è negativo, esegue rotl(value, -s)
. I bit che "cadono" del bit più a sinistra vengono ruotati di nuovo nel bit più a destra.
#include <bit>
#include <bitset>
#include <iostream>
int main()
{
unsigned char bits = 128;
for (int i = 0; i < 8; ++i)
{
std::cout << "rotr(0b" << std::bitset<8>(bits) << ", 1) = ";
bits = std::rotr(bits, 1);
std::cout << "0b" << std::bitset<8>(bits) << '\n';
}
std::cout << "rotr(0b" << std::bitset<8>(bits) << ",-1) = ";
bits = std::rotr(bits, -1);
std::cout << "0b" << std::bitset<8>(bits);
return 0;
}
rotr(0b10000000, 1) = 0b01000000
rotr(0b01000000, 1) = 0b00100000
rotr(0b00100000, 1) = 0b00010000
rotr(0b00010000, 1) = 0b00001000
rotr(0b00001000, 1) = 0b00000100
rotr(0b00000100, 1) = 0b00000010
rotr(0b00000010, 1) = 0b00000001
rotr(0b00000001, 1) = 0b10000000
rotr(0b10000000,-1) = 0b00000001
Questa funzione modello partecipa alla risoluzione dell'overload solo se T
è un tipo integer senza segno. Ad esempio: unsigned int
, unsigned long
unsigned short
, , unsigned char
e così via.
Intestazione: <bit>
Spazio dei nomi: std
/std:c++20
o versione successiva è obbligatoria.