funciones`<bit>`

Artículo
06/16/2023

El encabezado <bit> incluye las siguientes funciones de plantilla no miembro:

Funciones no miembro	Descripción
`bit_cast`	Reinterpreta la representación del objeto de un tipo a otro.
`bit_ceil`	Busca la potencia más pequeña de dos mayores o iguales que un valor.
`bit_floor`	Busca la potencia más grande de dos no mayor que un valor.
`bit_width`	Busca el número más pequeño de bits necesarios para representar un valor.
`countl_zero`	Cuenta el número de bits consecutivos establecidos en cero, empezando por el bit más significativo.
`countl_one`	Cuenta el número de bits consecutivos establecidos en uno, empezando por el bit más significativo.
`countr_zero`	Cuenta el número de bits consecutivos establecidos en cero, empezando por el bit menos significativo.
`countr_one`	Cuenta el número de bits consecutivos establecidos en uno, empezando por el bit menos significativo.
`has_single_bit`	Comprueba si un valor tiene un solo bit establecido en uno. Esto es lo mismo que probar si un valor es una potencia de dos.
`popcount`	Cuenta el número de bits establecidos en uno.
`rotl`	Calcula el resultado de un giro a la izquierda bit a bit.
`rotr`	Calcula el resultado de un giro a la derecha bit a bit.

`bit_cast`

Copie un patrón de bits de un objeto de tipo From en un nuevo objeto de tipo To.

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

Parámetros

Para
Tipo de la salida.

From
Tipo del valor al que se va a convertir.

from
Valor que se va a convertir.

Valor devuelto

Objeto de tipo To.

Cada bit del resultado coincide con el bit correspondiente de from, a menos que haya bits de relleno en To, en cuyo caso esos bits del resultado no se especifican.

Ejemplo

#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

Comentarios

A menudo, el código de bajo nivel necesita interpretar un objeto de un tipo como otro. El objeto reinterpretado tiene la misma representación de bits que el original, pero es un tipo diferente.

En lugar de usar reinterpret_cast, o memcpy(), bit_cast() es una manera mejor de realizar estas conversiones. Es mejor por las razones siguientes:

bit_cast() es constexpr.
bit_cast() requiere que los tipos se puedan copiar trivialmente y tengan el mismo tamaño. Esto evita posibles problemas que podrían producirse al usar reinterpret_cast y memcpy, ya que podrían emplearse de forma involuntaria y convertir incorrectamente tipos que no se pueden copiar de forma trivial. Además, memcpy() se puede usar para copiar accidentalmente entre tipos que no tienen el mismo tamaño. Por ejemplo, un tipo doble (8 bytes) en un entero sin signo (4 bytes), o viceversa.

Esta sobrecarga solo participa en la resolución de la sobrecarga si se dan las circunstancias siguientes:

sizeof(To) == sizeof(From)
To y From son is_trivially_copyable.

Esta plantilla de función es constexpr únicamente si To, From y los tipos de sus subobjetos cumplen estos requisitos:

No son un tipo de unión o puntero.
No son un tipo de puntero a miembro.
No están calificados como volátiles.
No tienen ningún miembro de datos no estático que sea un tipo de referencia.

`bit_ceil`

Busca la potencia más pequeña de dos mayores o iguales que un valor. Por ejemplo, dado 3, devuelve 4.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

La potencia más pequeña de dos mayores o iguales que value.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`bit_floor`

Busca la potencia más grande de dos no mayor que un valor. Por ejemplo, dado 5, devuelve 4.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

La mayor potencia de dos que no es mayor que value.
Si value es cero, devuelve cero.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`bit_width`

Busca el número más pequeño de bits necesarios para representar un valor.

Por ejemplo, dado 5 (0b101), devuelve 3 porque toma 3 bits binarios para expresar el valor 5.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

El número de bits necesarios para representar value.
Si value es cero, devuelve cero.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`countl_zero`

Cuenta el número de bits consecutivos establecidos en cero, empezando por el bit más significativo.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

El número de bits cero consecutivos, empezando por el bit más significativo.
Si value es cero, el número de bits del tipo de value.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`countl_one`

Cuenta el número de bits consecutivos establecidos en uno, empezando por el bit más significativo.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

El número de bits consecutivos establecidos en uno, empezando por el bit más significativo.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`countr_zero`

Cuenta el número de bits consecutivos establecidos en cero, empezando por el bit menos significativo.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

El número de bits cero consecutivos, empezando por el bit menos significativo.
Si value es cero, el número de bits del tipo de value.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`countr_one`

Cuenta el número de bits consecutivos establecidos en uno, empezando por el bit menos significativo.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

El número de bits consecutivos establecidos en uno, empezando por el bit menos significativo.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`has_single_bit`

Comprueba si un valor tiene solo un bit establecido. Esto es lo mismo que probar si un valor es una potencia de dos.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

true si value solo tiene un bits establecido, lo que también significa que value es una potencia de dos. En caso contrario, es false.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`popcount`

Cuenta el número de bits establecidos en uno en un valor entero sin signo.

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

Parámetros

value
Valor entero sin signo que se va a probar.

Valor devuelto

El número de bits establecidos en uno en value.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`rotl`

Gira los bits de un valor entero sin signo a la izquierda el número de veces especificado. Los bits que quedan fuera del bit más a la izquierda se giran hacia el bit más a la derecha.

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

Parámetros

value
Valor entero sin signo que se va a girar.

s
Número de rotaciones a la izquierda que se van a realizar.

Valor devuelto

Resultado de girar value a la izquierda s veces.
Si s es cero, devuelve value.
Si s es negativo, realiza rotr(value, -s). Los bits que quedan fuera del bit más a la derecha se giran hacia el bit más a la izquierda.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

`rotr`

Gira los bits de value a la derecha el número de veces especificado. Los bits que quedan fuera del bit más a la derecha se vuelven a girar hacia el bit más a la izquierda.

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

Parámetros

value
Valor entero sin signo que se va a girar.

s
Número de rotaciones a la derechas que se van a realizar.

Valor devuelto

Resultado de girar value a la derecha s veces.
Si s es cero, devuelve value.
Si s es negativo, realiza rotl(value, -s). Los bits que quedan fuera del bit más a la izquierda se vuelven a girar hacia el bit más a la derecha.

Ejemplo

#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

Comentarios

Esta función de plantilla solo participa en la resolución de sobrecargas si T es un tipo entero sin signo. Por ejemplo: unsigned int, unsigned long, unsigned short, unsigned char, etc.

Requisitos

Encabezado: <bit>

Espacio de nombres: std

Se requiere /std:c++20 o posterior.

Consulte también

<bit>

Compartir a través de

funciones<bit>

bit_cast

Parámetros

Valor devuelto

Ejemplo

Comentarios

bit_ceil

Parámetros

Valor devuelto

Ejemplo

Comentarios

bit_floor

Parámetros

Valor devuelto

Ejemplo

Comentarios

bit_width

Parámetros

Valor devuelto

Ejemplo

Comentarios

countl_zero

Parámetros

Valor devuelto

Ejemplo

Comentarios

countl_one

Parámetros

Valor devuelto

Ejemplo

Comentarios

countr_zero

Parámetros

Valor devuelto

Ejemplo

Comentarios

countr_one

Parámetros

Valor devuelto

Ejemplo

Comentarios

has_single_bit

Parámetros

Valor devuelto

Ejemplo

Comentarios

popcount

Parámetros

Valor devuelto

Ejemplo

Comentarios

rotl

Parámetros

Valor devuelto

Ejemplo

Comentarios

rotr

Parámetros

Valor devuelto

Ejemplo

Comentarios

Requisitos

Consulte también

Comentarios

Recursos adicionales

funciones`<bit>`

`bit_cast`

`bit_ceil`

`bit_floor`

`bit_width`

`countl_zero`

`countl_one`

`countr_zero`

`countr_one`

`has_single_bit`

`popcount`

`rotl`

`rotr`