Namespaces
Variants

std:: bitset

From cppreference.net
C++
Utilities library
std::bitset
Definido en el encabezado <bitset>
template < std:: size_t N >
class bitset ;

La plantilla de clase bitset representa una secuencia de tamaño fijo de N bits. Los bitsets pueden ser manipulados mediante operadores lógicos estándar y convertidos hacia y desde cadenas y enteros. Para el propósito de la representación de cadenas y de nombrar direcciones para operaciones de desplazamiento, la secuencia se considera con sus elementos de índice más bajo en la derecha , como en la representación binaria de enteros.

bitset cumple con los requisitos de CopyConstructible y CopyAssignable .

Todas las funciones miembro de std::bitset son constexpr : es posible crear y utilizar objetos std::bitset en la evaluación de una expresión constante.

(desde C++23)

Contenidos

Parámetros de plantilla

N - el número de bits para asignar almacenamiento

Tipos de miembros

clase proxy que representa una referencia a un bit
(clase)

Funciones miembro

construye el bitset
(función miembro pública)
(eliminado en C++20)
compara los contenidos
(función miembro pública)
Acceso a elementos
accede a un bit específico
(función miembro pública)
accede a un bit específico
(función miembro pública)
verifica si todos, alguno o ninguno de los bits están establecidos a true
(función miembro pública)
retorna el número de bits establecidos a true
(función miembro pública)
Capacidad
retorna el número de bits que contiene el bitset
(función miembro pública)
Modificadores
realiza operaciones binarias AND, OR, XOR y NOT
(función miembro pública)
realiza desplazamiento binario a izquierda y derecha
(función miembro pública)
establece bits a true o a un valor dado
(función miembro pública)
establece bits a false
(función miembro pública)
alterna los valores de los bits
(función miembro pública)
Conversiones
retorna una representación en cadena de los datos
(función miembro pública)
retorna una representación entera unsigned long de los datos
(función miembro pública)
(C++11)
retorna una representación entera unsigned long long de los datos
(función miembro pública)

Funciones no miembro

realiza operaciones lógicas binarias en bitsets
(plantilla de función)
realiza entrada y salida de flujo de bitsets
(plantilla de función)

Clases auxiliares

(C++11)
soporte de hash para std::bitset
(especialización de plantilla de clase)

Notas

Si el tamaño de un conjunto de bits no se conoce en tiempo de compilación, o es necesario cambiar su tamaño en tiempo de ejecución, se pueden utilizar tipos dinámicos como std::vector<bool> o boost::dynamic_bitset<> en su lugar.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_constexpr_bitset 202207L (C++23) Un std::bitset más constexpr
__cpp_lib_bitset 202306L (C++26) Interconexión de std::bitset con std::string_view

Ejemplo

Ejecutar este código 
#include <bitset>
#include <cassert>
#include <cstddef>
#include <iostream>
int main()
{
    typedef std::size_t length_t, position_t; // las pistas
    // constructores:
    constexpr std::bitset<4> b1;
    constexpr std::bitset<4> b2{0xA}; // == 0B1010
    std::bitset<4> b3{"0011"}; // también puede ser constexpr desde C++23
    std::bitset<8> b4{"ABBA", length_t(4), /*0:*/'A', /*1:*/'B'}; // == 0B0000'0110
    // los bitsets pueden imprimirse en un flujo:
    std::cout << "b1:" << b1 << "; b2:" << b2 << "; b3:" << b3 << "; b4:" << b4 << '\n';
    // bitset soporta operaciones bit a bit:
    b3 |= 0b0100; assert(b3 == 0b0111);
    b3 &= 0b0011; assert(b3 == 0b0011);
    b3 ^= std::bitset<4>{0b1100}; assert(b3 == 0b1111);
    // operaciones sobre el conjunto completo:
    b3.reset(); assert(b3 == 0);
    b3.set(); assert(b3 == 0b1111);
    assert(b3.all() && b3.any() && !b3.none());
    b3.flip(); assert(b3 == 0);
    // operaciones sobre bits individuales:
    b3.set(position_t(1), true); assert(b3 == 0b0010);
    b3.set(position_t(1), false); assert(b3 == 0);
    b3.flip(position_t(2)); assert(b3 == 0b0100);
    b3.reset(position_t(2)); assert(b3 == 0);
    // se soporta el operador de subíndice []:
    b3[2] = true; assert(true == b3[2]);
    // otras operaciones:
    assert(b3.count() == 1);
    assert(b3.size() == 4);
    assert(b3.to_ullong() == 0b0100ULL);
    assert(b3.to_string() == "0100");
}

Salida: 

b1:0000; b2:1010; b3:0011; b4:00000110

Véase también

bitset dinámico eficiente en espacio
(especialización de plantilla de clase)
Manipulación de bits (C++20) utilidades para acceder, manipular y procesar bits individuales y secuencias de bits