Classe `bitset`

Artigo
07/05/2024

Descreve um tipo de objeto que armazena uma sequência que consiste em um número fixo de bits que fornecem uma maneira compacta de manter sinalizadores para um conjunto de itens ou condições. A classe bitset dá suporte a operações em objetos do tipo bitset que contêm uma coleção de bits e fornecem acesso constante a cada bit.

Sintaxe

template <size_t N>
class bitset

Parâmetros

N
Especifica o número de bits no objeto bitset com um inteiro diferente de zero do tipo size_t que precisa ser conhecido no tempo de compilação.

Comentários

Ao contrário da classe vector<bool> semelhante, a classe bitset não tem iteradores e não é um contêiner da Biblioteca Padrão C++. Ela também é diferente de vector<bool> por ser de um tamanho específico que é fixado no tempo de compilação de acordo com o tamanho especificado pelo parâmetro de modelo N quando o bitset<N> é declarado.

Um bit será definido se seu valor for 1 e redefinido se seu valor for 0. Virar ou inverter um bit é alterar seu valor de 1 para 0 ou de 0 para 1. Os N bits em um bitset são indexados por valores inteiros de 0 a N - 1, em que 0 indexa a posição do primeiro bit e N - 1 a posição do bit final.

Membros

Construtores

Nome	Descrição
`bitset`	Constrói um objeto da classe `bitset<N>` e inicializa os bits como zero, para algum valor especificado ou para valores obtidos dos caracteres em uma cadeia de caracteres.

Typedefs

Nome	Descrição
`element_type`	Um tipo que é um sinônimo do tipo de dados `bool` e pode ser usado para referenciar os bits de elemento em um `bitset`.

Funções

Nome	Descrição
`all`	Testa todos os bits nesse `bitset` para determinar se eles estão todos definidos como `true`.
`any`	A função membro testa se qualquer bit na sequência está definido como 1.
`count`	A função membro retorna o número de bits definido na sequência de bits.
`flip`	Inverte o valor de todos os bits em um `bitset` ou inverte um único bit em uma posição especificada.
`none`	Testa se nenhum bit foi definido como 1 em um objeto `bitset`.
`reset`	Redefine todos os bits em um `bitset` como 0 ou redefine um bit em uma posição especificada como 0.
`set`	Define todos os bits em um `bitset` como 1 ou define um bit em uma posição especificada como 1.
`size`	Retorna o número de bits em um objeto `bitset`.
`test`	Testa se o bit em uma posição especificada em um `bitset` está definido como 1.
`to_string`	Converte um objeto `bitset` em uma representação de cadeia de caracteres.
`to_ullong`	Retorna a soma dos valores de no `bitset` como um `unsigned long long`.
`to_ulong`	Converte um objeto `bitset` no `unsigned long` que geraria a sequência de bits contidos se fosse usado para inicializar o `bitset`.

Classes

Nome	Descrição
`reference`	Uma classe de proxy que fornece referências aos bits contidos em um `bitset` que é usado para acessar e manipular os bits individuais como uma classe auxiliar do `operator[]` da classe `bitset`.

Operadores

Nome	Descrição
`operator!=`	Testa um `bitset` de destino quanto à desigualdade em relação a um `bitset` especificado.
`operator&=`	Executa uma combinação bit a bit de bitsets com a operação lógica "and" (`&`) bit a bit.
`operator<<`	Desloca os bits em um `bitset` um número especificado de posições à esquerda e retorna o resultado para um novo `bitset`.
`operator<<=`	Desloca os bits em um `bitset` um número especificado de posições à esquerda e retorna o resultado para o `bitset` de destino.
`operator==`	Testa um `bitset` de destino quanto à igualdade em relação a um `bitset` especificado.
`operator>>`	Desloca os bits em um `bitset` um número especificado de posições à direita e retorna o resultado para um novo `bitset`.
`operator>>=`	Desloca os bits em um `bitset` um número especificado de posições à direita e retorna o resultado para o `bitset` de destino.
`operator[]`	Retornará uma referência a um bit em uma posição especificada em um `bitset` se o `bitset` for modificável, caso contrário, retornará o valor do bit nessa posição.
operator^=	Executa uma combinação bit a bit de bitsets com a operação lógica "xor" (`^`) bit a bit.
`operator\|=`	Executa uma combinação bit a bit de bitsets com a operação lógica "or" (`\|`) bit a bit.
`operator~`	Inverte todos os bits em um `bitset` de destino e retorna o resultado.

Estruturas

Nome	Descrição
`hash`

`all`

Testa todos os bits nesse bitset para determinar se todos estão definidos como true.

bool all() const;

Valor de retorno

Retornará true se todos os bits nesse conjunto forem true. Retornará false se um ou mais bits forem false.

`any`

Testa se algum bit na sequência está definido como 1.

bool any() const;

Valor de retorno

true se algum bit no bitset estiver definido como 1, false se todos os bits forem 0.

Exemplo

// bitset_any.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 6 );
   bool b, rb;

   cout << "The original bitset b1( 6 ) is: ( "<< b1 << " )"
        << endl;

   b = b1.any ( );

   if ( b )
      cout << "At least one of the bits in bitset is set to 1."
           << endl;
   else
      cout << "None of the bits in bitset are set to 1."
           << endl;

   bitset<5> rb1;
   rb1 = b1.reset ( );

   cout << "The reset bitset is: ( "<< b1 << " )"
        << endl;

   rb = rb1.any ( );

   if ( rb )
      cout << "At least one of the bits in the reset bitset "
           << "are set to 1." << endl;
   else
      cout << "None of the bits in bitset b1 are set to 1."
           << endl;
}

The original bitset b1( 6 ) is: ( 00110 )
At least one of the bits in bitset is set to 1.
The reset bitset is: ( 00000 )
None of the bits in bitset b1 are set to 1.

`bitset`

Constrói um objeto da classe bitset<N> e inicializa os bits como zero, como algum valor especificado ou como os valores obtidos dos caracteres em uma cadeia de caracteres.

1) constexpr bitset();
2) bitset(unsigned long val);
3) constexpr bitset(unsigned long long val);
4) template <class CharType, class Traits, class Allocator>
    explicit bitset(
        const basic_string<CharType, Traits, Allocator>& str,
        typename basic_string<CharType, Traits, Allocator>::size_type pos = 0);
    
5) template <class CharType, class Traits, class Allocator>
    explicit bitset(
        const basic_string<CharType, Traits, Allocator>& str,
        typename basic_string<CharType, Traits, Allocator>::size_type pos,
        typename basic_string<CharType, Traits, Allocator>::size_type count,
        CharType Zero = CharType ('0'),
        CharType One = CharType ('1'));
    
6) template<class CharType>
    explicit bitset(
        const CharType* str,
        typename basic_string<CharType>::size_type
        n = basic_string<CharType>::npos,
        CharType zero = CharType('0'),
        CharType one = CharType('1'));

Parâmetros

val
O inteiro sem sinal cuja representação de base dois é usada para inicializar os bits no bitset que está sendo construído.

str
A cadeia de caracteres de zeros e uns usada para inicializar os valores de bits do bitset.

pos
A posição do caractere na cadeia de caracteres, contando da esquerda para a direita e começando com zero, usada para inicializar o primeiro bit no bitset.

count
O número de caracteres na cadeia de caracteres que é usado para fornecer os valores iniciais dos bits no bitset.

Zero
O caractere que é usado para representar um zero. O padrão é '0'.

One
O caractere que é usado para representar um. O padrão é '1'.

Comentários

1) Constrói um objeto da classe bitset<N> e inicializa todos os N bits com um valor padrão igual a zero.

2-3) Constrói um objeto da classe bitset<N> e inicializa os bits do parâmetro val.

4) Constrói um objeto da classe bitset<N> e inicializa os bits dos caracteres fornecidos em uma cadeia de caracteres de zeros e uns. Se algum caractere da cadeia de caracteres for diferente de 0 ou 1, o construtor gerará um objeto da classe invalid argument. Se a posição especificada (pos) estiver além do comprimento da cadeia de caracteres, o construtor gerará um objeto da classe out_of_range. O construtor apenas define os bits na posição j no bitset cujo caractere na cadeia de caracteres na posição pos + j é 1. Por padrão, pos é 0.

5) Semelhante a 4), mas inclui outro parâmetro, count, que especifica o número de bits a serem inicializados. Ele também tem dois parâmetros opcionais, _Zero e _One, que indicam qual caractere em str deve ser interpretado como um bit 0 e um bit 1, respectivamente.

6) Constrói um objeto da classe bitset<N>, inicializando os N bits com os valores que correspondem aos caracteres fornecidos em uma cadeia de caracteres do estilo C de zeros e uns. Chame o construtor sem converter a cadeia de caracteres em um tipo de cadeia de caracteres, por exemplo: bitset<5> b5("01011");

Exemplo

// bitset_bitset.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   // Using the default constructor
   using namespace std;
   bitset<2> b0;
   cout << "The set of bits in bitset<2> b0 is: ( "
        << b0 << " )." << endl;

   // Using the second member function
   bitset<5> b1 ( 6 );
   cout << "The set of bits in bitset<5> b1( 6 ) is: ( "
        << b1 << " )." << endl;

   // The template parameter N can be an expression
   bitset< 2 * sizeof ( int ) > b2;
   cout << "The set of bits in bitset< 2 * sizeof ( int ) > b2 is: ( "
        << b2 << " )." << endl;

   // The base two representation will be truncated
   // if its length exceeds the size of the bitset
   bitset<3> b3 ( 6 );
   cout << "The set of bits in bitset<3> b3( 6 ) is ( "
        << b3 << " )." << endl;

   // Using a c-style string to initialize the bitset
    bitset<7> b3andahalf ( "1001001" );
    cout << "The set of bits in bitset<7> b3andahalf ( \"1001001\" )"
         << " is ( " << b3andahalf << " )." << endl;

   // Using the fifth member function with the first parameter
   string bitval4 ( "10011" );
   bitset<5> b4 ( bitval4 );
   cout << "The set of bits in bitset<5> b4( bitval4 ) is ( "
        << b4 << " )." << endl;

   // Only part of the string may be used for initialization

   // Starting at position 3 for a length of 6 (100110)
   string bitval5 ("11110011011");
   bitset<6> b5 ( bitval5, 3, 6 );
   cout << "The set of bits in bitset<11> b5( bitval, 3, 6 ) is ( "
        << b5 << " )." << endl;

   // The bits not initialized with part of the string
   // will default to zero
   bitset<11> b6 ( bitval5, 3, 5 );
   cout << "The set of bits in bitset<11> b6( bitval5, 3, 5 ) is ( "
        << b6 << " )." << endl;

   // Starting at position 2 and continue to the end of the string
   bitset<9> b7 ( bitval5, 2 );
   cout << "The set of bits in bitset<9> b7( bitval, 2 ) is ( "
        << b7 << " )." << endl;
}

The set of bits in bitset<2> b0 is: ( 00 ).
The set of bits in bitset<5> b1( 6 ) is: ( 00110 ).
The set of bits in bitset<2 * sizeof ( int ) > b2 is: ( 00000000 ).
The set of bits in bitset<3> b3( 6 ) is ( 110 ).
The set of bits in bitset<5> b4( bitval4 ) is ( 10011 ).
The set of bits in bitset<11> b5( bitval, 3, 6 ) is ( 100110 ).
The set of bits in bitset<11> b6( bitval5, 3, 5 ) is ( 00000010011 ).
The set of bits in bitset<9> b7( bitval, 2 ) is ( 110011011 ).

`count`

Retorna o número de bits definidos na sequência de bits.

size_t count() const;

Valor de retorno

O número de bits definidos na sequência de bits.

Exemplo

// bitset_count.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
    using namespace std;

    bitset<5> b1(4);

    cout << "The collection of bits in the original bitset is: ( "
         << b1 << " )" << endl;

    size_t i;
    i = b1.count();
    cout << "The number of bits in the bitset set to 1 is: "
         << i << "." << endl;

    bitset<5> fb1;
    fb1 = b1.flip();

    cout << "The collection of flipped bits in the modified bitset "
         << "is: ( " << b1 << " )" << endl;

    size_t ii;
    ii = fb1.count();
    cout << "The number of bits in the bitset set to 1 is: "
         << ii << "." << endl;
}

The collection of bits in the original bitset is: ( 00100 )
The number of bits in the bitset set to 1 is: 1.
The collection of flipped bits in the modified bitset is: ( 11011 )
The number of bits in the bitset set to 1 is: 4.

`element_type`

Um tipo que é um sinônimo do tipo de dados bool e pode ser usado para referenciar os bits de elemento em um bitset.

typedef bool element_type;

Exemplo

// bitset_elem_type.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<3> b1 ( 2 );
   cout << "Original bitset b1(6) is: ( "<< b1 << " )"
        << endl;

   //Compare two ways to reference bits in a bitset
   bool b;
   bitset<5>::element_type e;

   b = b1.test ( 2 );
   if ( b )
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 1." << endl;
   else
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 0." << endl;
   b1[2] = 1;
   cout << "Bitset b1 modified by b1[2] = 1 is: ( "<< b1 << " )"
        << endl;

   e = b1.test ( 2 );
   if ( e )
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 1." << endl;
   else
      cout << "The bit at position 2 of bitset b1"
           << "has a value of 0." << endl;
}

Original bitset b1(6) is: ( 010 )
The bit at position 2 of bitset b1has a value of 0.
Bitset b1 modified by b1[2] = 1 is: ( 110 )
The bit at position 2 of bitset b1has a value of 1.

`flip`

Inverte o valor de todos os bits em um bitset ou inverte um único bit em uma posição especificada.

bitset<N>& flip();
bitset<N>& flip(size_t pos);

Parâmetros

pos
A posição do bit cujo valor deve ser invertido.

Valor de retorno

Uma cópia do bitset modificado para o qual a função membro foi invocada.

Comentários

A segunda função membro gera uma exceção out_of_range quando a posição especificada como um parâmetro é maior que o tamanho N do bitset<N> cujo bit foi invertido.

Exemplo

// bitset_flip.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 6 );

   cout << "The collection of bits in the original bitset is: ( "
        << b1 << " )" << endl;

   bitset<5> fb1;
   fb1 = b1.flip ( );

   cout << "After flipping all the bits, the bitset becomes: ( "
        << fb1 << " )" << endl;

   bitset<5> f3b1;
   f3b1 = b1.flip ( 3 );

   cout << "After flipping the fourth bit, the bitset becomes: ( "
        << f3b1 << " )" << endl << endl;

   bitset<5> b2;
   int i;
   for ( i = 0 ; i <= 4 ; i++ )
   {
      b2.flip(i);
      cout << b2 << "  The bit flipped is in position "
           << i << ".\n";
   }
}

The collection of bits in the original bitset is: ( 00110 )
After flipping all the bits, the bitset becomes: ( 11001 )
After flipping the fourth bit, the bitset becomes: ( 10001 )

00001  The bit flipped is in position 0.
00011  The bit flipped is in position 1.
00111  The bit flipped is in position 2.
01111  The bit flipped is in position 3.
11111  The bit flipped is in position 4.

`hash`

template <class T> struct hash;
template <size_t N> struct hash<bitset<N>>;

nenhum

Testa se nenhum bit foi definido como 1 em um objeto bitset.

bool none() const;

Valor de retorno

true se nenhum bit no bitset tiver sido definido como 1, false se pelo menos um bit foi definido como 1.

Exemplo

// bitset_none.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 6 );
   bool b, rb;

   cout << "Original bitset b1(6) is: ( " << b1 << " )"
        << endl;

   b = b1.none ( );

   if ( b )
      cout << "None of the bits in bitset b1 are set to 1."
           << endl;
   else
      cout << "At least one of the bits in bitset b1 is set to 1."
           << endl;

   bitset<5> rb1;
   rb1 = b1.reset ( );
   rb = rb1.none ( );
   if ( rb )
      cout << "None of the bits in bitset b1 are set to 1."
           << endl;
   else
      cout << "At least one of the bits in bitset b1 is set to 1."
           << endl;
}

Original bitset b1(6) is: ( 00110 )
At least one of the bits in bitset b1 is set to 1.
None of the bits in bitset b1 are set to 1.

`operator!=`

Testa um conjunto de bits de destino quanto à desigualdade em relação a um bitset especificado.

bool operator!=(const bitset<N>& right) const;

Parâmetros

right
O bitset a ser comparado com o bitset de destino quanto à desigualdade.

Valor de retorno

true se os bitsets forem diferentes, false se eles forem iguais.

Comentários

Os bitsets precisam ter o mesmo tamanho.

Exemplo

// bitset_op_NE.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 7 );
   bitset<5> b3 ( 2 );
   bitset<4> b4 ( 7 );

   if ( b1 != b2 )
      cout << "Bitset b1 is different from bitset b2." << endl;
   else
      cout << "Bitset b1 is the same as bitset b2." << endl;

   if ( b1 != b3 )
      cout << "Bitset b1 is different from bitset b3." << endl;
   else
      cout << "Bitset b1 is the same as bitset b3." << endl;

   // This would cause an error because bitsets must have the
   // same size to be tested
   // if ( b1 != b4 )
   //   cout << "Bitset b1 is different from bitset b4." << endl;
   // else
   //   cout << "Bitset b1 is the same as bitset b4." << endl;
}

Bitset b1 is the same as bitset b2.
Bitset b1 is different from bitset b3.

`operator&=`

Executa uma combinação bit a bit de bitsets com a operação lógica "and" (&) bit a bit.

bitset<N>& operator&=(const bitset<N>& right);

Parâmetros

right
O bitset que deve ser combinado bit a bit com o bitset de destino.

Valor de retorno

O bitset de destino modificado que resulta da operação "and" (&) bit a bit com o bitset especificado como um parâmetro.

Comentários

Dois bits combinados pelo operador AND retornarão true se cada bit for true, caso contrário, a combinação retornará false.

Os dois bitsets precisam ter o mesmo tamanho.

Exemplo

// bitset_op_bitwise.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 11 );
   bitset<4> b3 ( 7 );

   cout << "The target bitset b1 is:    ( "<< b1 << " )." << endl;
   cout << "The parameter bitset b2 is: ( "<< b2 << " )." << endl;
   cout << endl;

   b1 &= b2;
   cout << "After bitwise AND combination,\n"
        << "the target bitset b1 becomes:   ( "<< b1 << " )."
        << endl;

   // Note that the parameter-specified bitset is unchanged
   cout << "The parameter bitset b2 remains: ( "<< b2 << " )."
        << endl;

   // The following would cause an error because the bisets
   // must be of the same size to be combined
   // b1 &= b3;
}

The target bitset b1 is:    ( 00111 ).
The parameter bitset b2 is: ( 01011 ).

After bitwise AND combination,
the target bitset b1 becomes:   ( 00011 ).
The parameter bitset b2 remains: ( 01011 ).

`operator<<`

Desloca os bits em um bitset um número especificado de posições à esquerda e retorna o resultado para um novo bitset.

bitset<N> operator<<(size_t pos) const;

Parâmetros

pos
O número de posições à esquerda que os bits no bitset devem ser deslocados.

Valor de retorno

O bitset modificado com os bits deslocados o número necessário de posições à esquerda.

Comentários

A função membro de operador retorna bitset(*this) <<= pos, em que <<= desloca os bits em um bitset um número especificado de posições à esquerda e retorna o resultado ao bitset de destino.

Exemplo

// bitset_op_LS.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );

   cout << "The bitset b1 is: ( "<< b1 << " )." << endl;

   bitset<5> b2;
   b2 = b1 << 2;

   cout << "After shifting the bits 2 positions to the left,\n"
        << " the bitset b2 is: ( "<< b2 << " )."
        << endl;

   bitset<5> b3 = b2 >> 1;

   cout << "After shifting the bits 1 position to the right,\n"
        << " the bitset b3 is: ( " << b3 << " )."
        << endl;
}

`operator<<=`

Desloca os bits em um bitset um número especificado de posições à esquerda e retorna o resultado para o bitset de destino.

bitset<N>& operator<<=(size_t pos);

Parâmetros

pos
O número de posições para a esquerda que os bits no bitset devem ser deslocados.

Valor de retorno

O bitset de destino modificado de maneira que os bits foram deslocados o número necessário de posições à esquerda.

Comentários

Se não existir nenhum elemento na posição, a função limpará o bit para o valor 0.

Exemplo

// bitset_op_LSE.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   cout << "The target bitset b1 is: ( "<< b1 << " )." << endl;
   b1 <<= 2;
   cout << "After shifting the bits 2 positions to the left,\n"
        << "the target bitset b1 becomes: ( "<< b1 << " )."
        << endl;
}

The target bitset b1 is: ( 00111 ).
After shifting the bits 2 positions to the left,
the target bitset b1 becomes: ( 11100 ).

`operator==`

Testa um bitset de destino quanto à igualdade com um bitset especificado.

bool operator==(const bitset<N>& right) const;

Parâmetros

right
O bitset a ser comparado com o bitset de destino quanto à igualdade.

Valor de retorno

true se os bitsets forem iguais, false se eles forem diferentes.

Comentários

Os bitsets precisam ter o mesmo tamanho.

Exemplo

// bitset_op_EQ.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 7 );
   bitset<5> b3 ( 2 );
   bitset<4> b4 ( 7 );

   if ( b1 == b2 )
      cout << "Bitset b1 is the same as bitset b2." << endl;
   else
      cout << "Bitset b1 is different from bitset b2." << endl;

   if ( b1 == b3 )
      cout << "Bitset b1 is the same as bitset b3." << endl;
   else
      cout << "Bitset b1 is different from bitset b3." << endl;

   // This would cause an error because bitsets must have the
   // same size to be tested
   // if ( b1 == b4 )
   //   cout << "Bitset b1 is the same as bitset b4." << endl;
   // else
   //   cout << "Bitset b1 is different from bitset b4." << endl;
}

Bitset b1 is the same as bitset b2.
Bitset b1 is different from bitset b3.

`operator>>`

Desloca os bits em um bitset um número especificado de posições à direita e retorna o resultado para um novo bitset.

bitset<N> operator>>(size_t pos) const;

Parâmetros

pos
O número de posições à direita que os bits no bitset devem ser deslocados.

Valor de retorno

Um novo bitset para o qual os bits foram deslocados à direita um número necessário de posições relativas ao bitset de destino.

Exemplo

// bitset_op_RS.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   cout << "The bitset b1 is: ( "<< b1 << " )." << endl;

   bitset<5> b2;
   b2 = b1 << 2;

   cout << "After shifting the bits 2 positions to the left,\n"
        << "the bitset b2 is: ( "<< b2 << " )."
        << endl;
   bitset<5> b3 = b2 >> 1;

   cout << "After shifting the bits 1 position to the right,\n"
        << "the bitset b3 is: ( " << b3 << " )."
        << endl;
}

The bitset b1 is: ( 00111 ).
After shifting the bits 2 positions to the left,
the bitset b2 is: ( 11100 ).
After shifting the bits 1 position to the right,
the bitset b3 is: ( 01110 ).

`operator>>=`

Desloca os bits em um bitset um número especificado de posições à direita e retorna o resultado para o bitset de destino.

bitset<N>& operator>>=(size_t pos);

Parâmetros

pos
O número de posições à direita que os bits no bitset devem ser deslocados.

Valor de retorno

O bitset de destino modificado com os bits deslocados o número necessário de posições à direita.

Comentários

Se não existir nenhum elemento na posição, a função limpará o bit para o valor 0.

Exemplo

// bitset_op_RSE.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 28 );
   cout << "The target bitset b1 is: ( "<< b1 << " )." << endl;

   b1 >>= 2;
   cout << "After shifting the bits 2 positions to the right,\n"
        << "the target bitset b1 becomes: ( "<< b1 << " )."
        << endl;
}

The target bitset b1 is: ( 11100 ).
After shifting the bits 2 positions to the right,
the target bitset b1 becomes: ( 00111 ).

`operator[]`

Retornará uma referência a um bit em uma posição especificada em um bitset se o bitset for modificável, caso contrário, retornará o valor do bit nessa posição.

bool operator[](size_t pos) const;
reference operator[](size_t pos);

Parâmetros

pos
A posição que localiza o bit dentro do bitset.

Comentários

Quando você definir _ITERATOR_DEBUG_LEVEL como 1 ou 2 no build, um erro de runtime ocorrerá em seu executável se você tentar acessar um elemento fora dos limites do bitset. Para obter mais informações, consulte Iteradores verificados.

Exemplo

// bitset_op_REF.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bool b;
   bitset<5> b1 ( 6 );
   cout << "The initialized bitset<5> b1( 2 ) is: ( "<< b1 << " )."
        << endl;

   int i;
   for ( i = 0 ; i <= 4 ; i++ )
   {
      b = b1[ i ];
      cout << "  The bit in position "
           << i << " is " << b << ".\n";
   }
}

`operator^=`

Executa uma combinação bit a bit de bitsets com a operação lógica "xor" (^) bit a bit.

bitset<N>& operator^=(const bitset<N>& right);

Parâmetros

right
O bitset que deve ser combinado bit a bit com o bitset de destino.

Valor de retorno

O bitset de destino modificado que resulta da operação "xor" bit a bit (^) com o bitset especificado como um parâmetro.

Comentários

Dois bits combinados pelo operador "xor" (^) exclusivo retornam true se pelo menos um, mas não os dois bits são true, caso contrário, a combinação retorna false.

Os bitsets precisam ter o mesmo tamanho.

Exemplo

// bitset_op_bitwiseOR.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;
   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 11 );
   bitset<4> b3 ( 7 );

   cout << "The target bitset b1 is:    ( "<< b1 << " )." << endl;
   cout << "The parameter bitset b2 is: ( "<< b2 << " )." << endl;
   cout << endl;

   b1 ^= b2;
   cout << "After bitwise exclusive OR combination,\n"
        << "the target bitset b1 becomes:   ( "<< b1 << " )."
        << endl;

   // Note that the parameter-specified bitset in unchanged
   cout << "The parameter bitset b2 remains: ( "<< b2 << " )."
        << endl;

   // The following would cause an error because the bitsets
   // must be of the same size to be combined
   // b1 |= b3;
}

The target bitset b1 is:    ( 00111 ).
The parameter bitset b2 is: ( 01011 ).

After bitwise exclusive OR combination,
the target bitset b1 becomes:   ( 01100 ).
The parameter bitset b2 remains: ( 01011 ).

`operator|=`

Combina dois bitsets usando a operação bit a bit "or" (|).

bitset<N>& operator|=(const bitset<N>& right);

Parâmetros

right
O bitset que deve ser combinado bit a bit com o bitset de destino.

Valor de retorno

O bitset de destino modificado que resulta da operação "or" (|) bit a bit com o bitset especificado como um parâmetro.

Comentários

Dois bits combinados pelo operador OR inclusivo retornarão true se pelo menos um dos bits for true. Se os dois bits forem false, a combinação deles retornará false.

Os bitsets precisam ter o mesmo tamanho.

Exemplo

// bitset_op_BIO.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2 ( 11 );
   bitset<4> b3 ( 7 );

   cout << "The target bitset b1 is:    ( "<< b1 << " )." << endl;
   cout << "The parameter bitset b2 is: ( "<< b2 << " )." << endl;
   cout << endl;

   b1 |= b2;
   cout << "After bitwise inclusive OR combination,\n"
        << "the target bitset b1 becomes:   ( "<< b1 << " )."
        << endl;

   // Note that the parameter-specified bitset in unchanged
   cout << "The parameter bitset b2 remains: ( "<< b2 << " )."
        << endl;

   // The following would cause an error because the bisets
   // must be of the same size to be combined
   // b1 |= b3;
}

The target bitset b1 is:    ( 00111 ).
The parameter bitset b2 is: ( 01011 ).

After bitwise inclusive OR combination,
the target bitset b1 becomes:   ( 01111 ).
The parameter bitset b2 remains: ( 01011 ).

`operator~`

Inverte todos os bits em um bitset de destino e retorna o resultado.

bitset<N> operator~() const;

Valor de retorno

O bitset com todos os bits dele invertidos em relação ao bitset de destino.

Exemplo

// bitset_op_invert.cpp
// compile with: /EHsc
#include <iostream>
#include <string>
#include <bitset>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );
   bitset<5> b2;
   b2 = ~b1;

   cout << "Bitset b1 is: ( "<< b1 << " )." << endl;
   cout << "Bitset b2 = ~b1 is: ( "<< b2 << " )." << endl;

   // These bits could also be flipped using the flip member function
   bitset<5> b3;
   b3 = b1.flip( );
   cout << "Bitset b3 = b1.flip( ) is: ( "<< b2 << " )." << endl;
}

Bitset b1 is: ( 00111 ).
Bitset b2 = ~b1 is: ( 11000 ).
Bitset b3 = b1.flip( ) is: ( 11000 ).

`reference`

Uma classe de proxy que fornece referências aos bits contidos em um bitset que é usado para acessar e manipular os bits individuais como uma classe auxiliar do operator[] da classe bitset.

class reference {
   friend class bitset<N>;
public:
   reference& operator=(bool val);
   reference& operator=(const reference& bitref);
   bool operator~() const;
   operator bool() const;
   reference& flip();
};

Parâmetros

val
O valor do objeto do tipo bool a ser atribuído a um bit em um bitset.

bitref
Uma referência da forma x [ i ] ao bit na posição i em bitset x.

Valor de retorno

Uma referência ao bit no bitset especificado pela posição do argumento da primeira, da segunda e da quinta função membro de referência de classe e true ou false para refletir o valor do bit modificado no bitset da terceira e da quarta funções membro de referência de classe.

Comentários

A classe reference existe apenas como uma classe auxiliar para o bitset operator[]. A classe member descreve um objeto que pode acessar um bit individual em um bitset. Permita que b seja um objeto do tipo bool, x e y sejam objetos do tipo bitset<N>, e i e j sejam posições válidas dentro desse objeto. A notação x [i] referencia o bit na posição i no bitset x. As funções membro da classe reference fornecem, em ordem, as seguintes operações:

Operação	Definição
`x`[`i`] = `b`	Armazena o valor `bool` `b` na posição de bit `i` no bitset `x`.
`x`[`i`] = `y`[`j`]	Armazena o valor do bit `y`[ `j`] na posição de bit `i` no bitset `x`.
`b` = ~ `x`[`i`]	Armazena o valor invertido do bit `x`[ `i`] em `bool` `b`.
`b` = `x`[`i`]	Armazena o valor do bit `x`[ `i`] em `bool` `b`.
`x`[`i`]. `flip`( )	Armazena o valor invertido do bit `x`[ `i`] novamente na posição de bit `i` em `x`.

Exemplo

// bitset_reference.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 2 );
   bitset<5> b2 ( 6 );
   cout << "The initialized bitset<5> b1( 2 ) is: ( "<< b1 << " )."
        << endl;
   cout << "The initialized bitset<5> b2( 6 ) is: ( "<< b2 << " )."
        << endl;

   // Example of x [i] = b storing bool b at bit position i
   // in bitset x
   b1[ 0 ] = true;
   cout << "The bitset<5> b1 with the bit at position 0 set to 1"
        << "is: ( "<< b1 << " )" << endl;

   // Example of x [i] = y [j] storing the bool value of the
   // bit at position j in bitset y at bit position i in bitset x
   b2 [4] = b1 [0];      // b1 [0] = true
   cout << "The bitset<5> b2 with the bit at position 4 set to the "
        << "value\nof the bit at position 0 of the bit in "
        << "bitset<5> b1 is: ( "<<  b2  << " )" << endl;

   // Example of b = ~x [i] flipping the value of the bit at
   // position i of bitset x and storing the value in an
   // object b of type bool
   bool b = ~b2 [4];      // b2 [4] = false
   if ( b )
      cout << "The value of the object b = ~b2 [4] "
           << "of type bool is true." << endl;
   else
      cout << "The value of the object b = ~b2 [4] "
           << "of type bool is false." << endl;

   // Example of b = x [i] storing the value of the bit at
   // position i of bitset x in the object b of type bool
   b = b2 [4];
   if ( b )
      cout << "The value of the object b = b2 [4] "
           << "of type bool is true." << endl;
   else
      cout << "The value of the object b = b2 [4] "
           << "of type bool is false." << endl;

   // Example of x [i] . flip ( ) toggling the value of the bit at
   // position i of bitset x
   cout << "Before flipping the value of the bit at position 4 in "
        << "bitset b2,\nit is ( "<<  b2  << " )." << endl;
   b2 [4].flip( );
   cout << "After flipping the value of the bit at position 4 in "
        << "bitset b2,\nit becomes ( "<<  b2  << " )." << endl;
   bool c;
   c = b2 [4].flip( );
   cout << "After a second flip, the value of the position 4 "
        << "bit in b2 is now: " << c << ".";
}

The initialized bitset<5> b1( 2 ) is: ( 00010 ).
The initialized bitset<5> b2( 6 ) is: ( 00110 ).
The bitset<5> b1 with the bit at position 0 set to 1 is: ( 00011 )
The bitset<5> b2 with the bit at position 4 set to the value
of the bit at position 0 of the bit in bitset<5> b1 is: ( 10110 )
The value of the object b = ~b2 [4] of type bool is false.
The value of the object b = b2 [4] of type bool is true.
Before flipping the value of the bit at position 4 in bitset b2,
it is ( 10110 ).
After flipping the value of the bit at position 4 in bitset b2,
it becomes ( 00110 ).
After a second flip, the value of the position 4 bit in b2 is now: 1.

`reset`

Redefine todos os bits em um bitset como 0 ou redefine um bit em uma posição especificada como 0.

bitset<N>& reset();
bitset<N>& reset(size_t pos);

Parâmetros

pos
A posição do bit no bitset a ser redefinido como 0.

Valor de retorno

Uma cópia do bitset para o qual a função membro foi invocada.

Comentários

A segunda função membro gera uma exceção out_of_range quando a posição especificada é maior que o tamanho do bitset.

Exemplo

// bitset_reset.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 13 );
   cout << "The set of bits in bitset<5> b1(13) is: ( "<< b1 << " )"
        << endl;

   bitset<5> b1r3;
   b1r3 = b1.reset( 2 );
   cout << "The collection of bits obtained from resetting the\n"
        << "third bit of bitset b1 is: ( "<< b1r3 << " )"
        << endl;

   bitset<5> b1r;
   b1r = b1.reset( );
   cout << "The collecion of bits obtained from resetting all\n"
        << "the elements of the bitset b1 is: ( "<< b1r << " )"
        << endl;
}

The set of bits in bitset<5> b1(13) is: ( 01101 )
The collecion of bits obtained from resetting the
third bit of bitset b1 is: ( 01001 )
The collecion of bits obtained from resetting all
the elements of the bitset b1 is: ( 00000 )

`set`

Define todos os bits em um bitset como 1 ou define um bit em uma posição especificada como 1.

bitset<N>& set();

bitset<N>& set(
    size_t pos,
    bool val = true);

Parâmetros

pos
A posição do bit no bitset a ser definido como o valor atribuído.

val
O valor a ser atribuído ao bit na posição especificada.

Valor de retorno

Uma cópia do bitset para o qual a função membro foi invocada.

Comentários

A segunda função membro gera uma exceção out_of_range quando a posição especificada é maior que o tamanho do bitset.

Exemplo

// bitset_set.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 6 );
   cout << "The set of bits in bitset<5> b1(6) is: ( "<< b1 << " )"
        << endl;

   bitset<5> b1s0;
   b1s0 = b1.set( 0 );
   cout << "The collecion of bits obtained from setting the\n"
        << "zeroth bit of bitset b1 is: ( "<< b1s0 << " )"
        << endl;

   bitset<5> bs1;
   bs1 = b1.set( );
   cout << "The collecion of bits obtained from setting all the\n"
        << "elements of the bitset b1 is: ( "<< bs1 << " )"
        << endl;
}

The set of bits in bitset<5> b1(6) is: ( 00110 )
The collecion of bits obtained from setting the
zeroth bit of bitset b1 is: ( 00111 )
The collecion of bits obtained from setting all the
elements of the bitset b1 is: ( 11111 )

`size`

Retorna o número de bits em um objeto bitset.

size_t size() const;

Valor de retorno

O número de bits, N, em um bitset<N>.

Exemplo

// bitset_size.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main()
{
    using namespace std;

    bitset<5> b1(6);
    size_t i;

    cout << "The set of bits in bitset<5> b1( 6 ) is: ( "<< b1 << " )"
         << endl;

    i = b1.size();

    cout << "The number of bits in bitset b1 is: " << i << "."
         << endl;
}

The set of bits in bitset<5> b1( 6 ) is: ( 00110 )
The number of bits in bitset b1 is: 5.

`test`

Testa se o bit em uma posição especificada em um bitset está definido como 1.

bool test(size_t pos) const;

Parâmetros

pos
A posição do bit no bitset a ser testado quanto ao valor dele.

Valor de retorno

true se o bit especificado pela posição de argumento estiver definido como 1, caso contrário, false.

Comentários

A função membro gera um out_of_range

`to_string`

Converte um objeto bitset em uma representação de cadeia de caracteres.

template <class charT = char, class traits = char_traits<charT>, class Allocator = allocator<charT> >
   basic_string<charT, traits, Allocator> to_string(charT zero = charT('0'), charT one = charT('1')) const;

Valor retornado

Um objeto de cadeia de caracteres de classe basic_string, em que cada bit definido no bitset tem um caractere correspondente de 1 e um caractere de 0 se o bit não estiver definido.

Exemplo

// bitset_to_string.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );

   cout << "The ordered set of bits in the bitset<5> b1( 7 )"
        << "\n  that was generated by the number 7 is: ( "
        << b1 << " )" << endl;

   string s1;
   s1 =  b1.template to_string<char,
   char_traits<char>, allocator<char> >( );
   cout << "The string returned from the bitset b1"
        << "\n  by the member function to_string( ) is: "
        << s1 << "." << endl;
}

The ordered set of bits in the bitset<5> b1( 7 )
  that was generated by the number 7 is: ( 00111 )
The string returned from the bitset b1
  by the member function to_string( ) is: 00111.

`to_ullong`

Retorna um valor unsigned long long que contém os mesmos bits definidos como o conteúdo do objeto bitset.

unsigned long long to_ullong() const;

Valor retornado

Retorna a soma dos valores de bit presentes na sequência de bits como um unsigned long long. Esse valor unsigned long long recriaria os mesmos bits definidos se fosse usado para inicializar um bitset.

Exceções

Lançará um objeto overflow_error se qualquer bit na sequência de bits tiver um valor de bit que não possa ser representado como um valor do tipo unsigned long long.

Comentários

Retorna a soma dos valores de bit presentes na sequência de bits como um unsigned long long.

`to_ulong`

Converte um objeto bitset no inteiro que geraria a sequência de bits contidos se fosse usado para inicializar o bitset.

unsigned long to_ulong( ) const;

Valor retornado

Um inteiro que geraria os bits em um bitset se usado na inicialização do bitset.

Comentários

A aplicação da função membro retornaria o inteiro que tem a mesma sequência de 1 e 0 dígitos que é encontrada na sequência de bits contida no bitset.

A função membro lançará um objeto overflow_error se qualquer bit na sequência de bits tiver um valor de bit que não possa ser representado como um valor do tipo unsigned long.

Exemplo

// bitset_to_ulong.cpp
// compile with: /EHsc
#include <bitset>
#include <iostream>

int main( )
{
   using namespace std;

   bitset<5> b1 ( 7 );

   cout << "The ordered set of bits in the bitset<5> b1( 7 )"
        << "\n  that was generated by the number 7 is: ( "
        << b1 << " )" << endl;

   unsigned long int i;
   i = b1.to_ulong( );
   cout << "The integer returned from the bitset b1,"
        << "\n  by the member function to_long( ), that"
        << "\n  generated the bits as a base two number is: "
        << i << "." << endl;
}

The ordered set of bits in the bitset<5> b1( 7 )
  that was generated by the number 7 is: ( 00111 )
The integer returned from the bitset b1,
  by the member function to_long( ), that
  generated the bits as a base two number is: 7.

Compartilhar via

Classe bitset

Sintaxe

Parâmetros

Comentários

Membros

Construtores

Typedefs

Funções

Classes

Operadores

Estruturas

all

Valor de retorno

any

Valor de retorno

Exemplo

bitset

Parâmetros

Comentários

Exemplo

count

Valor de retorno

Exemplo

element_type

Exemplo

flip

Parâmetros

Valor de retorno

Comentários

Exemplo

hash

nenhum

Valor de retorno

Exemplo

operator!=

Parâmetros

Valor de retorno

Comentários

Exemplo

operator&=

Parâmetros

Valor de retorno

Comentários

Exemplo

operator<<

Parâmetros

Valor de retorno

Comentários

Exemplo

operator<<=

Parâmetros

Valor de retorno

Comentários

Exemplo

operator==

Parâmetros

Valor de retorno

Comentários

Exemplo

operator>>

Parâmetros

Valor de retorno

Exemplo

operator>>=

Parâmetros

Valor de retorno

Comentários

Exemplo

operator[]

Parâmetros

Comentários

Exemplo

operator^=

Parâmetros

Valor de retorno

Comentários

Exemplo

operator|=

Parâmetros

Classe `bitset`

`all`

`any`

`bitset`

`count`

`element_type`

`flip`

`hash`

`operator!=`

`operator&=`

`operator<<`

`operator<<=`

`operator==`

`operator>>`

`operator>>=`

`operator[]`

`operator^=`

`operator|=`

`operator~`

`reference`

`reset`

`set`

`size`

`test`

`to_string`

`to_ullong`

`to_ulong`