Namespaces
Variants

std::bitset<N>:: bitset

From cppreference.net
C++
Utilities library
std::bitset
bitset ( ) ;
(1) (noexcept desde C++11)
(constexpr desde C++11)
(2)
bitset ( unsigned long val ) ;
(hasta C++11)
constexpr bitset ( unsigned long long val ) noexcept ;
(desde C++11)
template < class CharT, class Traits, class Alloc >

explicit bitset
( const std:: basic_string < CharT, Traits, Alloc > & str,
typename std:: basic_string
< CharT, Traits, Alloc > :: size_type pos = 0 ,
typename std:: basic_string < CharT, Traits, Alloc > :: size_type
n = std:: basic_string < CharT, Traits, Alloc > :: npos ,

CharT zero = CharT ( '0' ) , CharT one = CharT ( '1' ) ) ;
(3) (constexpr desde C++23)
template < class CharT, class Traits >

constexpr explicit bitset
( std:: basic_string_view < CharT, Traits > str,
std:: size_t pos = 0 , std:: size_t n = std:: size_t ( - 1 ) ,

CharT zero = CharT ( '0' ) , CharT one = CharT ( '1' ) ) ;
(4) (desde C++26)
template < class CharT >

explicit bitset ( const CharT * str, std:: size_t n = std:: size_t ( - 1 ) ,

CharT zero = CharT ( '0' ) , CharT one = CharT ( '1' ) ) ;
(5) (desde C++11)
(constexpr desde C++23)

Construye un nuevo conjunto de bits a partir de una de varias fuentes de datos opcionales:

1) Constructor por defecto. Construye un bitset con todos los bits establecidos a cero.
2) Construye un bitset a partir de un entero sin signo val .
Dado el número de bits en la representación de valor de unsigned long (hasta C++11) unsigned long long (desde C++11) como S :
  • Las primeras (más a la derecha, menos significativas) std:: min ( S, N ) posiciones de bit se inicializan con los valores de bit correspondientes de val .
  • Si S es menor que N , las posiciones de bit restantes se inicializan a ceros.
3) Construye un bitset utilizando los caracteres en str . Se puede proporcionar una posición inicial opcional pos y longitud n , así como caracteres que denoten valores alternativos para bits establecidos ( one ) y no establecidos ( zero ). Traits::eq() se utiliza para comparar los valores de los caracteres.
La longitud efectiva de la cadena de inicialización es std:: min ( n, str. size ( ) - pos ) .
4) Similar a (3) , pero utiliza un std::basic_string_view en lugar de un std::basic_string .
5) Similar a (3) , pero utiliza un const CharT * en lugar de un std::basic_string .

Equivalente a bitset ( n == std:: basic_string < CharT > :: npos
? std:: basic_string < CharT > ( str )
: std:: basic_string < CharT > ( str, n ) , 0 , n, zero, one ) .

(hasta C++26)

Equivalente a bitset ( n == std:: basic_string_view < CharT > :: npos
? std:: basic_string_view < CharT > ( str )
: std:: basic_string_view < CharT > ( str, n ) , 0 , n, zero, one ) .

(desde C++26)

Contenidos

Parámetros

val - número utilizado para inicializar el bitset
str - cadena utilizada para inicializar el bitset
pos - desplazamiento inicial en str
n - número de caracteres a utilizar de str
zero - carácter alternativo para bits no establecidos en str
one - carácter alternativo para bits establecidos en str

Excepciones

3,4) std::out_of_range si pos > str. size ( ) , std::invalid_argument si algún carácter no es one o zero .
5) std::invalid_argument si algún carácter no es one o zero .

Notas

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

Ejemplo

Ejecutar este código 
#include <bitset>
#include <climits>
#include <iostream>
#include <string>
int main()
{
    // constructor vacío (1)
    std::bitset<8> b1; // [0,0,0,0,0,0,0,0]
    // constructor unsigned long long (2)
    std::bitset<8> b2(42);          // [0,0,1,0,1,0,1,0]
    std::bitset<70> bl(ULLONG_MAX); // [0,0,0,0,0,0,1,1,1,...,1,1,1] en C++11
    std::bitset<8> bs(0xfff0);      // [1,1,1,1,0,0,0,0]
    // constructor de cadena (3)
    std::string bit_string = "110010";
    std::bitset<8> b3(bit_string);       // [0,0,1,1,0,0,1,0]
    std::bitset<8> b4(bit_string, 2);    // [0,0,0,0,0,0,1,0]
    std::bitset<8> b5(bit_string, 2, 3); // [0,0,0,0,0,0,0,1]
    // constructor de cadena usando dígitos cero/uno personalizados (3)
    std::string alpha_bit_string = "aBaaBBaB";
    std::bitset<8> b6(alpha_bit_string, 0, alpha_bit_string.size(),
                      'a', 'B');         // [0,1,0,0,1,1,0,1]
    // constructor char* usando dígitos personalizados (5)
    std::bitset<8> b7("XXXXYYYY", 8, 'X', 'Y'); // [0,0,0,0,1,1,1,1]
    std::cout <<   "b1: " << b1 << "\nb2: " << b2 << "\nbl: " << bl
              << "\nbs: " << bs << "\nb3: " << b3 << "\nb4: " << b4
              << "\nb5: " << b5 << "\nb6: " << b6 << "\nb7: " << b7 << '\n';
}

Salida posible: 

b1: 00000000
b2: 00101010
bl: 0000001111111111111111111111111111111111111111111111111111111111111111
bs: 11110000
b3: 00110010
b4: 00000010
b5: 00000001
b6: 01001101
b7: 00001111

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 396 C++98 los valores de los caracteres cero y uno para la sobrecarga (3)
eran ​ 0 ​ y 1 (que no corresponden a '0' y '1' ) 		se añadieron parámetros para proporcionar
valores para estos caracteres
LWG 457 C++98 S era CHAR_BIT * sizeof ( unsigned long )
para la sobrecarga (2) , pero unsigned long no está
garantizado que use todos sus bits para representar su valor 		considerar el número
de bits de la representación
del valor en su lugar
LWG 2250 C++98 el comportamiento era indefinido si pos > str. size ( ) es true siempre lanza una
excepción en este caso

Véase también

establece bits a true o al valor dado
(función miembro pública)
establece bits a false
(función miembro pública)