Namespaces
Variants

std::bitset<N>:: bitset

From cppreference.net
C++
Utilities library
std::bitset
bitset ( ) ;
(1) (noexcept depuis C++11)
(constexpr depuis C++11)
(2)
bitset ( unsigned long val ) ;
(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 jeu de bits à partir de l'une des plusieurs sources de données optionnelles :

1) Constructeur par défaut. Construit un bitset avec tous les bits initialisés à zéro.
2) Construit un bitset à partir d'un entier non signé val .
Étant donné le nombre de bits dans la représentation de la valeur de unsigned long (jusqu'à C++11) unsigned long long (depuis C++11) comme S :
  • Les premières positions de bit (les plus à droite, les moins significatives) std:: min ( S, N ) sont initialisées avec les valeurs de bit correspondantes de val .
  • Si S est inférieur à N , les positions de bit 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 désignant des valeurs alternatives pour les bits définis ( one ) et non définis ( 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 à bitset ( n == std:: basic_string < CharT > :: npos
? std:: basic_string < CharT > ( str )
: std:: basic_string < CharT > ( str, n ) , 0 , n, zero, one ) .

(jusqu'à C++26)

Équivalent à 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 ) .

(depuis C++26)

Table des matières

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 .
5) 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)