Funções `<bit>`

Artigo
07/05/2024

O cabeçalho <bit> inclui as seguintes funções de modelo não membro:

Funções de não membro	Descrição
`bit_cast`	Reinterpretar a representação de objeto de um tipo para outro.
`bit_ceil`	Localize a menor potência de dois maiores que ou iguais a um valor.
`bit_floor`	Encontre a maior potência de dois não maiores que um valor.
`bit_width`	Localize o menor número de bits necessários para representar um valor.
`countl_zero`	Conte o número de bits consecutivos definido como zero, começando com o bit mais significativo.
`countl_one`	Conte o número de bits consecutivos definido como um, começando com o bit mais significativo.
`countr_zero`	Conte o número de bits consecutivos definidos como zero, começando com o bit menos significativo.
`countr_one`	Conte o número de bits consecutivos definido como um, começando com o bit menos significativo.
`has_single_bit`	Verifique se um valor tem apenas um bit definido como um. Isso é o mesmo que testar se um valor é uma potência de dois.
`popcount`	Conte o número de bits definido como um.
`rotl`	Compute o resultado de uma rotação à esquerda bit a bit.
`rotr`	Compute o resultado de uma rotação à direita bit a bit.

`bit_cast`

Copie um padrão de bit de um objeto do tipo From para um novo objeto do tipo To.

template <class To, class From>
[[nodiscard]] constexpr To bit_cast(const From& from) noexcept;

Parâmetros

Para
O tipo de saída.

De
O tipo do valor para converter.

de
O valor a ser convertido.

Valor retornado

Um objeto do tipo To.

Cada bit no resultado corresponde ao bit correspondente em from, a menos que haja bits de preenchimento em To, então esses bits no resultado não serão especificados.

Exemplo

#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

Comentários

O código de baixo nível geralmente precisa interpretar um objeto de um tipo como outro. O objeto reinterpretado tem a mesma representação de bit que o original, mas é de um tipo diferente.

Em vez de usar reinterpret_cast, ou memcpy(), bit_cast() é uma forma melhor de fazer essas conversões. É melhor porque:

bit_cast() é constexpr
bit_cast() requer que os tipos sejam trivialmente copiados e do mesmo tamanho. Isso impede possíveis problemas que você pode encontrar usando reinterpret_cast e memcpy porque eles podem ser usados de modo inadvertido e incorreto, convertendo tipos não trivialmente copiados. Além disso, memcpy() pode ser usado para copiar inadvertidamente entre tipos que não têm o mesmo tamanho. Por exemplo, um duplo (8 bytes) em um int sem sinal (4 bytes) ou o contrário.

Essa sobrecarga só participará da resolução de sobrecarga se:

sizeof(To) == sizeof(From)
To e From forem is_trivially_copyable.

Esse modelo de função é constexpr se, e somente se, To, From e os tipos de seus sub-objetos:

Não são um tipo de união ou ponteiro
Não são um ponteiro para o tipo de membro
Não são qualificado por volátil
Não têm nenhum membro de dados não estático que seja um tipo de referência

`bit_ceil`

Localize a menor potência de dois maiores que ou iguais a um valor. Por exemplo, dado 3, retorna 4.

template<class T>
[[nodiscard]] constexpr T bit_ceil(T value);

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

O menor poder de dois maior ou igual a value.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`bit_floor`

Encontre a maior potência de dois não maiores que um valor. Por exemplo, dado 5, retorna 4.

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

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

A maior potência de dois que não é maior do que value.
Se value for zero, retornará zero.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`bit_width`

Localize o menor número de bits necessários para representar um valor.

Por exemplo, dado 5 (0b101), retorna 3 porque são necessários 3 bits binários para expressar o valor 5.

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

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

O número de bits necessários para representar value.
Se value for zero, retornará zero.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`countl_zero`

Conte o número de bits consecutivos definido como zero, começando com o bit mais significativo.

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

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

O número de bits zero consecutivos, começando pelo bit mais significativo.
Se value for zero, o número de bits no tipo de value.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`countl_one`

Conte o número de bits consecutivos definido como um, começando com o bit mais significativo.

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

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

O número de bits consecutivos definido como um, começando pelo bit mais significativo.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`countr_zero`

Conte o número de bits consecutivos definidos como zero, começando com o bit menos significativo.

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

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

O número de bits zero consecutivos, começando do bit menos significativo.
Se value for zero, o número de bits no tipo de value.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`countr_one`

Conte o número de bits consecutivos definido como um, começando com o bit menos significativo.

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

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

O número de bits consecutivos definido como um, começando com o bit menos significativo.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`has_single_bit`

Verifique se um valor tem apenas um bit definido. Isso é o mesmo que testar se um valor é uma potência de dois.

template <class T>
[[nodiscard]] constexpr bool has_single_bit(T value) noexcept;

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

true se value tiver apenas um conjunto de bits, o que também significa que value é uma potência de dois. Caso contrário, false.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`popcount`

Conte o número de bits definido como um em um valor inteiro sem sinal.

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

Parâmetros

value
O valor inteiro sem sinal a ser testado.

Valor retornado

Os bits de número definidos como um em value.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`rotl`

Gira os bits de um valor inteiro sem sinal restante o número de vezes especificado. Os bits que "caem" do bit mais à esquerda são girados para o bit mais à direita.

template<class T>
[[nodiscard]] constexpr T rotl(T value, int s) noexcept;

Parâmetros

value
O valor inteiro sem sinal a ser girado.

s
O número de rotações à esquerda a serem executadas.

Valor retornado

O resultado da rotação de value para a esquerda, s vezes.
Se s for zero, retornará value.
Se s for negativo, rotr(value, -s). Os bits que "caem" do bit mais à direita são girados para o bit mais à esquerda.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

`rotr`

Gira os bits de value para a direita o número especificado de vezes. Os bits que "caem" do bit mais à direita são girados de volta para o bit mais à esquerda.

template<class T>
[[nodiscard]] constexpr T rotr(T value, int s) noexcept;

Parâmetros

value
O valor inteiro sem sinal a ser girado.

s
O número de rotações à direita a serem executadas.

Valor retornado

O resultado da rotação de value para a direita, s vezes.
Se s for zero, retornará value.
Se s for negativo, rotl(value, -s). Os bits que "caem" do bit mais à esquerda são girados de volta para o bit mais à direita.

Exemplo

#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

Comentários

Essa função de modelo só participará da resolução de sobrecarga se T for um tipo inteiro sem sinal. Por exemplo: unsigned int, unsigned long, unsigned short, unsigned char etc.

Requisitos

Cabeçalho: <bit>

Namespace: std

/std:c++20 ou posterior é necessário.

Confira também

<bit>

Partilhar via

Funções <bit>

bit_cast

Parâmetros

Valor retornado

Exemplo

Comentários

bit_ceil

Parâmetros

Valor retornado

Exemplo

Comentários

bit_floor

Parâmetros

Valor retornado

Exemplo

Comentários

bit_width

Parâmetros

Valor retornado

Exemplo

Comentários

countl_zero

Parâmetros

Valor retornado

Exemplo

Comentários

countl_one

Parâmetros

Valor retornado

Exemplo

Comentários

countr_zero

Parâmetros

Valor retornado

Exemplo

Comentários

countr_one

Parâmetros

Valor retornado

Exemplo

Comentários

has_single_bit

Parâmetros

Valor retornado

Exemplo

Comentários

popcount

Parâmetros

Valor retornado

Exemplo

Comentários

rotl

Parâmetros

Valor retornado

Exemplo

Comentários

rotr

Parâmetros

Valor retornado

Exemplo

Comentários

Requisitos

Confira também

Comentários

Recursos adicionais

Funções `<bit>`

`bit_cast`

`bit_ceil`

`bit_floor`

`bit_width`

`countl_zero`

`countl_one`

`countr_zero`

`countr_one`

`has_single_bit`

`popcount`

`rotl`

`rotr`