std::bitset<N>::bitset
De es.cppreference.net
bitset();
|
(1) | (noexcept desde C++11) (constexpr desde C++11) |
bitset( unsigned long val );
|
(2) | (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 bitset 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 deval. - Si
Ses menor queN, las posiciones de bit restantes se inicializan a ceros.
3) Construye un bitset utilizando los caracteres en
str. Se pueden proporcionar una posición inicial opcional pos y una longitud n, así como caracteres que denoten valores alternativos para los 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 |
(hasta C++26) |
|
Equivalente a |
(desde C++26) |
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
.
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) |