std::bitset<N>::bitset
Depuis fr.cppreference.net
bitset();
|
(1) | (noexcept depuis C++11) (constexpr depuis C++11) |
bitset( unsigned long val );
|
(2) | (jusqu'à C++11) |
constexpr bitset( unsigned long long val ) noexcept;
|
(depuis 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 depuis 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) | (depuis 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) | (depuis C++11) (constexpr depuis C++23) |
Construit un nouveau bitset à partir d'une ou plusieurs sources de données optionnelles :
1) Constructeur par défaut. Construit un bitset avec tous les bits mis à zéro.
2) Construit un bitset à partir d'un entier non signé
val. Étant donné le nombre de bits dans la représentation de valeur de
unsigned long(jusqu'à C++11)unsigned long long(depuis C++11) comme S :
- Les
std::min(S, N)premières positions de bits (les plus à droite, les moins significatives) sont initialisées avec les valeurs de bits correspondantes deval. - Si
Sest inférieur àN, les positions de bits restantes sont initialisées à zéro.
3) Construit un bitset en utilisant les caractères dans
str. Une position de départ optionnelle pos et une longueur n peuvent être fournies, ainsi que des caractères indiquant des valeurs alternatives pour les bits à 1 (one) et à 0 (zero). Traits::eq() est utilisé pour comparer les valeurs des caractères. La longueur effective de la chaîne d'initialisation est
std::min(n, str.size() - pos).4) Similaire à (3), mais utilise un std::basic_string_view au lieu d'un std::basic_string.
5) Similaire à (3), mais utilise un
const CharT* au lieu d'un std::basic_string.
|
Équivalent à |
(jusqu'à C++26) |
|
Équivalent à |
(depuis C++26) |
Paramètres
| val | - | nombre utilisé pour initialiser le bitset |
| str | - | chaîne utilisée pour initialiser le bitset |
| pos | - | un décalage de départ dans str |
| n | - | nombre de caractères à utiliser depuis str |
| zero | - | caractère alternatif pour les bits non définis dans str |
| one | - | caractère alternatif pour les bits définis dans str |
Exceptions
3,4)
std::out_of_range
si
pos
>
str.
size
(
)
,
std::invalid_argument
si un caractère n'est pas
one
ou
zero
.
Notes
| Macro de test de fonctionnalité | Valeur | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_constexpr_bitset
|
202207L
|
(C++23) |
Un
std::bitset
plus constexpr,
surcharges
(
3,5
)
|
__cpp_lib_bitset
|
202306L
|
(C++26) |
Interface entre
std::bitset
et
std::string_view
,
(
4
)
|
Exemple
Exécuter ce code
#include <bitset> #include <climits> #include <iostream> #include <string> int main() { // constructeur vide (1) std::bitset<8> b1; // [0,0,0,0,0,0,0,0] // constructeur 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] // constructeur string (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] // constructeur string utilisant des chiffres personnalisés (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] // constructeur char* utilisant des chiffres personnalisés (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'; }
Sortie possible :
b1: 00000000 b2: 00101010 bl: 0000001111111111111111111111111111111111111111111111111111111111111111 bs: 11110000 b3: 00110010 b4: 00000010 b5: 00000001 b6: 01001101 b7: 00001111
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| LWG 396 | C++98 |
les valeurs des caractères zéro et un pour la surcharge
(3)
étaient 0 et 1 (qui ne correspondent pas à '0' et '1' ) |
ajout de paramètres pour fournir
les valeurs de ces caractères |
| LWG 457 | C++98 |
S
était
CHAR_BIT
*
sizeof
(
unsigned
long
)
pour la surcharge (2) , mais unsigned long ne garantit pas d'utiliser tous ses bits pour représenter sa valeur |
considérer le nombre
de bits de la représentation de la valeur à la place |
| LWG 2250 | C++98 | le comportement était indéfini si pos > str. size ( ) est true |
lève toujours une
exception dans ce cas |
Voir aussi
|
définit les bits à
true
ou à la valeur donnée
(fonction membre publique) |
|
|
définit les bits à
false
(fonction membre publique) |