`<bit>` funzioni

Articolo
10/12/2023

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.

`bit_cast`

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;

Parametri

Per
Tipo dell'output.

Da
Tipo del valore da convertire.

da
Valore da convertire.

Valore restituito

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.

Esempio

#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

Osservazioni:

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 usando reinterpret_cast e memcpy 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 e From sono is_trivially_copyable.

Questo modello di funzione è constexpr se e solo se To, Frome 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

`bit_ceil`

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);

Parametri

value
Valore intero senza segno da testare.

Valore restituito

La potenza più piccola di due maggiore o uguale a value.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`bit_floor`

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;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

La potenza più grande di due che non è maggiore di value.
Se value è zero, restituisce zero.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`bit_width`

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;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

Numero di bit necessari per rappresentare value.
Se value è zero, restituisce zero.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`countl_zero`

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;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

Numero di bit zero consecutivi, a partire dal bit più significativo.
Se value è zero, il numero di bit nel tipo di value.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`countl_one`

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;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

Numero di bit consecutivi impostati su uno, a partire dal bit più significativo.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`countr_zero`

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;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

Numero di bit zero consecutivi, a partire dal bit meno significativo.
Se value è zero, il numero di bit nel tipo di value.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`countr_one`

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;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

Numero di bit consecutivi impostati su uno, a partire dal bit meno significativo.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`has_single_bit`

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;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

true se value ha un solo bit impostato, il che significa anche che value è una potenza di due. In caso contrario, false.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`popcount`

Contare il numero di bit impostati su uno in un valore intero senza segno.

template<class T>
[[nodiscard]] constexpr int popcount(T value) noexcept;

Parametri

value
Valore intero senza segno da testare.

Valore restituito

I bit numerici impostati su uno in value.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`rotl`

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;

Parametri

value
Valore intero senza segno da ruotare.

s
Numero di rotazioni a sinistra da eseguire.

Valore restituito

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.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

`rotr`

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;

Parametri

value
Valore intero senza segno da ruotare.

s
Numero di rotazioni a destra da eseguire.

Valore restituito

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.

Esempio

#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

Osservazioni:

Questa funzione modello partecipa alla risoluzione dell'overload solo se T è un tipo integer senza segno. Ad esempio: unsigned int, unsigned longunsigned short, , unsigned chare così via.

Requisiti

Intestazione: <bit>

Spazio dei nomi: std

/std:c++20 o versione successiva è obbligatoria.

Vedi anche

<bit>

Condividi tramite

<bit> funzioni

bit_cast

Parametri

Valore restituito

Esempio

Osservazioni:

bit_ceil

Parametri

Valore restituito

Esempio

Osservazioni:

bit_floor

Parametri

Valore restituito

Esempio

Osservazioni:

bit_width

Parametri

Valore restituito

Esempio

Osservazioni:

countl_zero

Parametri

Valore restituito

Esempio

Osservazioni:

countl_one

Parametri

Valore restituito

Esempio

Osservazioni:

countr_zero

Parametri

Valore restituito

Esempio

Osservazioni:

countr_one

Parametri

Valore restituito

Esempio

Osservazioni:

has_single_bit

Parametri

Valore restituito

Esempio

Osservazioni:

popcount

Parametri

Valore restituito

Esempio

Osservazioni:

rotl

Parametri

Valore restituito

Esempio

Osservazioni:

rotr

Parametri

Valore restituito

Esempio

Osservazioni:

Requisiti

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive

`<bit>` funzioni

`bit_cast`

`bit_ceil`

`bit_floor`

`bit_width`

`countl_zero`

`countl_one`

`countr_zero`

`countr_one`

`has_single_bit`

`popcount`

`rotl`

`rotr`