Funções <bit>
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.
Retornar valor
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()éconstexprbit_cast()requer que os tipos sejam trivialmente copiados e do mesmo tamanho. Isso impede possíveis problemas que você pode encontrar usandoreinterpret_castememcpyporque 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)ToeFromforem 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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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.
Retornar valor
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
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de