Namespaces
Variants

Standard library header <bitset>

From cppreference.net
C++
Standard library headers

Cet en-tête fait partie de la bibliothèque d'utilitaires généraux .

Table des matières

Inclusions

std::basic_string modèle de classe
Déclarations anticipées de toutes les classes de la bibliothèque d'entrée/sortie

Classes

implémente un tableau de bits de longueur constante
(modèle de classe)
(C++11)
support de hachage pour std::bitset
(spécialisation de modèle de classe)
Déclarations anticipées
Défini dans l'en-tête <functional>
(C++11)
objet fonction de hachage
(modèle de classe)

Fonctions

effectue des opérations logiques binaires sur les bitsets
(modèle de fonction)
effectue l'entrée et la sortie en flux des bitsets
(modèle de fonction)

Synopsis 

#include <string>
#include <iosfwd>   // pour istream, ostream
namespace std {
  template<size_t N> class bitset;
  // opérateurs de bitset
  template<size_t N>
    constexpr bitset<N> operator&(const bitset<N>&, const bitset<N>&) noexcept;
  template<size_t N>
    constexpr bitset<N> operator|(const bitset<N>&, const bitset<N>&) noexcept;
  template<size_t N>
    constexpr bitset<N> operator^(const bitset<N>&, const bitset<N>&) noexcept;
  template<class CharT, class Traits, size_t N>
    basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, bitset<N>& x);
  template<class CharT, class Traits, size_t N>
    basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, const bitset<N>& x);
}

Modèle de classe std::bitset 

namespace std {
  template<size_t N> class bitset {
  public:
    // référence de bit
    class reference {
    public:
      constexpr reference(const reference&) = default;
      constexpr ~reference();
      constexpr reference& operator=(bool x) noexcept;           // pour b[i] = x;
      constexpr reference& operator=(const reference&) noexcept; // pour b[i] = b[j];
      constexpr bool operator~() const noexcept;                 // inverse le bit
      constexpr operator bool() const noexcept;                  // pour x = b[i];
      constexpr reference& flip() noexcept;                      // pour b[i].flip();
    };
    // constructeurs
    constexpr bitset() noexcept;
    constexpr bitset(unsigned long long val) noexcept;
    template<class CharT, class Traits, class Allocator>
      constexpr explicit bitset(
        const basic_string<CharT, Traits, Allocator>& str,
        typename basic_string<CharT, Traits, Allocator>::size_type pos = 0,
        typename basic_string<CharT, Traits, Allocator>::size_type n
          = basic_string<CharT, Traits, Allocator>::npos,
        CharT zero = CharT('0'),
        CharT one = CharT('1'));
    template<class CharT, class Traits>
      constexpr explicit bitset(
        basic_string_view<CharT, Traits> str,
        typename basic_string_view<CharT, Traits>::size_type pos = 0,
        typename basic_string_view<CharT, Traits>::size_type n
          = basic_string_view<CharT, Traits>::npos,
        CharT zero = CharT('0'),
        CharT one = CharT('1'));
    template<class CharT>
      constexpr explicit bitset(
        const CharT* str,
        typename basic_string_view<CharT>::size_type n = basic_string_view<CharT>::npos,
        CharT zero = CharT('0'),
        CharT one = CharT('1'));
    // opérations sur les bitset
    constexpr bitset& operator&=(const bitset& rhs) noexcept;
    constexpr bitset& operator|=(const bitset& rhs) noexcept;
    constexpr bitset& operator^=(const bitset& rhs) noexcept;
    constexpr bitset& operator<<=(size_t pos) noexcept;
    constexpr bitset& operator>>=(size_t pos) noexcept;
    constexpr bitset  operator<<(size_t pos) const noexcept;
    constexpr bitset  operator>>(size_t pos) const noexcept;
    constexpr bitset& set() noexcept;
    constexpr bitset& set(size_t pos, bool val = true);
    constexpr bitset& reset() noexcept;
    constexpr bitset& reset(size_t pos);
    constexpr bitset  operator~() const noexcept;
    constexpr bitset& flip() noexcept;
    constexpr bitset& flip(size_t pos);
    // accès aux éléments
    constexpr bool operator[](size_t pos) const;
    constexpr reference operator[](size_t pos);
    constexpr unsigned long to_ulong() const;
    constexpr unsigned long long to_ullong() const;
    template<class CharT = char,
             class Traits = char_traits<CharT>,
             class Allocator = allocator<CharT>>
      constexpr basic_string<CharT, Traits, Allocator>
        to_string(CharT zero = CharT('0'), CharT one = CharT('1')) const;
    // observateurs
    constexpr size_t count() const noexcept;
    constexpr size_t size() const noexcept;
    constexpr bool operator==(const bitset& rhs) const noexcept;
    constexpr bool test(size_t pos) const;
    constexpr bool all() const noexcept;
    constexpr bool any() const noexcept;
    constexpr bool none() const noexcept;
  };
  // support de hachage
  template<class T> struct hash;
  template<size_t N> struct hash<bitset<N>>;
}

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 4140 C++98 la synopsis contient une déclaration du constructeur
par défaut de std:: bitset < N > :: reference 		supprimé la
déclaration