bitset(unsigned long val)

C-2: Constructor que acepta un unsigned long como argumento. Crea un objeto de la clase bitset<N> que contiene la imagen de bits del argumento. Si sobra espacio porque N es mayor que la longitud necesaria, los bits restantes son puestos a cero.

Ejemplo:

bitset<125> bs2(64312UL); 

C-3: Constructor explícit que acepta un string str como argumento principal y otros dos argumentos numéricos adicionales pos y n, que tienen valores por defecto. El primero recibe el valor 0; el segundo el valor npos, que corresponde con el valor strlen(str)-pos.  Estos dos últimos argumentos permiten especificar si se utilizarán todos los miembros del string str o npos caracteres desde la posición pos hasta el final.

Los elementos de la cadena deben ser solo 0 o 1. El tamaño del bitset debe ser suficiente para albergar la cadena utilizada como argumento. En caso que sea mayor, los bits restantes se ponen a cero.

Ejemplo:

bitset<16> bs1("10010110101");

bitset<16> bs2("10a10110101");  // Error! (se lanza excepción)

bitset<16> bs3("10010110101", 3);

bitset<16> bs4("10010110101", 3, 4);

Resultados:

0000010010110101
0000000010110101
0000000000001011

Operador de igualdad; devuelve un bool. Cierto si todos los bits de ambos operandos coinciden. Falso en caso contrario. Solo está definido entre contenedores de igual tamaño.

Ejemplo:

if (bs1 == bs2) { /* ... */ }

Operador relacional inverso al anterior. Permite expresiones como:

if (bs1 != bs2) { /* ... */ } 

La expresión bs1 &= bs2; es en realidad una operación compuesta and_eq de un bitand ( 4.9.3) seguido de una asignación:

bs1 = (bs1 & bs2);

El resultado es que todos los bits del Lvalue cuyos correspondientes en el Rvalue son 0, son puestos a cero. El resto permanece inalterado.

Este operador binario se corresponde con una operación or_eq ( 4.9.3). Un bitor seguido de una asignación, de forma que las dos expresiones son equivalentes:

bs1 |= bs2;

bs1 = (bs1 | bs2);

El resultado es que todos los bits del Lvalue cuyos correspondientes en el Rvalue son 1 son puestos a uno. El resto permanece sin cambio.

Corresponde a una operación xor_eq ( 4.9.3);  un OR exclusivo (xor) seguido de una asignación. Las dos expresiones que siguen son equivalentes:

bs1 ^= bs2;

bs1 = (bs1 ^ bs2);

El resultado es que son cambiados todos los bits del Lvalue cuyos correspondientes en el Rvalue son 1. El resto permanece sin cambio.

Esta es una operación compuesta, corresponde a una operación de desplazamiento de bits seguido de una asignación:

bs1 <<= bs2;

bs1 = (bs1 << bs2);

El resultado es que se sustituye cada bit de posición i el Lvalue por otro valor según el siguiente criterio:

Si: i < pos, se sustituye por un 0.

Si: i >= pos, se sustituye por el valor del bit en la posición i - pos.

Este operador binario define una operación compuesta correspondiente a un desplazamiento de bits seguido de una asignación:

bs1 >>= bs2;

bs1 = (bs1 >> bs2);

El resultado es que se sustituye cada bit de posición i el Lvalue es sustituido por otro valor según el siguiente criterio:

Si: pos >= N - i, se sustituye por un 0.

Si: pos < N - i, se sustituye por el valor del bit en la posición  i + pos.

Devuelve

bitset<N>(*this) <<= pos 

Devuelve: bitset<N>(*this) >>= pos.

Ejemplo:

bitset<32> bs2(64312UL);
cout << "Imagen: " << bs2 << endl;
cout << "Imagen: " << (bs2>>1) << endl;
cout << "Imagen: " << (bs2<<1) << endl;

Salida:

Imagen: 00000000000000001111101100111000
Imagen: 00000000000000000111110110011100
Imagen: 00000000000000011111011001110000

Es el operador unario de complemento a uno. Construye un nuevo objeto x bitset <N> y lo inicializa con el valor del operando. A continuación cambia los valores de todos los bits, de forma que el objeto devuelto es el complemento a uno del argumento ( 2.2.4a).

Ejemplo:

bitset<32> bs2(64312UL);
cout << "Imagen: " << bs2 << endl;
cout << "Imagen: " << ~bs2 << endl;

Salida:

Imagen: 00000000000000001111101100111000
Imagen: 11111111111111110000010011000111

Operador binario que obtiene el AND lógico de lhs y rhs. Devuelve el valor:

bitset<N>(lhs) &= rhs.

Operador binario que obtiene el OR lógico de lhs y rhs. Devuelve el valor

bitset<N>(lhs) |= rhs 

Obtiene el XOR lógico de lhs y rhs. Devuelve el valor

bitset<N>(lhs) ^= rhs 

Este operador permite entradas formateadas. Extrae N caracteres simples [2] del flujo de entrada is, y se almacenan en un objeto temporal de tipo string () que denominaremos str. A continuación se crea un objeto temporal bitset y se realiza la asignación. Devuelve is.

x = bitset<N>(str)

El resultado es que el bitset utilizado como argumento x contiene N bits equivalentes a los caracteres del flujo de entrada ('0' es transformado en 0 y '1' en 1).

Los caracteres son extraídos del flujo hasta que se de alguna de las siguientes circunstancias:

• Se han extraido y almacenado todos los caracteres (N).
• Se encuentra un fin de fichero ("End of file") en la secuencia de entrada.
• El próximo carácter de la secuencia no es un cero ni un uno, en cuyo caso no es extraído.

Ejemplo:

bitset<16> bs3;
cin >> bs3;             // introducir datos por teclado
cout << "bs3 contiene: " << bs3 << endl;

Salida después de introducir la secuencia 1001010100110101001110101010101:

bs3 contiene: 1001010100110101 

Devuelve:

os << x.template to_string<charT,traits,allocator<charT> >()

Ver a continuación la declaración del método to_string( ).

Ejemplo:

bitset<32> bs2(64312UL);
cout << bs2 << endl; // -> 00000000000000001111101100111000 

Método que pone a 1 todos los elementos del objeto sobre el que opera. Ejemplo:

bs1.set();

Esta versión sobrecargada del método anterior requiere que el argumento pos sea válido. En caso contrario, si corresponde a un elemento no válido del contenedor, se lanza una excepción. El método fija el valor del elemento pos según el valor señalado por val. (observe que este argumento tiene un valor por defecto). Si val es cero, se almacena un cero (0). En caso contrario se almacena un uno (1). El ejemplo que sigue pone a 1 el quinto elemento del contenedor bs2:

bs2.set(5);

Este método hace el efecto contrario que set ().  Pone a cero todos los miembros del contenedor sobre el que opera.

Ejemplo:

bs1.reset(); 

Pone a cero el miembro señalado por el argumento pos, que debe ser una posición válida.

Ejemplo:

bs2.reset(5); 

Este método cambia el valor de todos los miembros del contenedor sobre el que opera (1s por 0s y 0s por 1s).

Ejemplo:

bs2.flip();

Cambia el valor del miembro de la posición señalada por el argumento. pos debe ser una posición válida. En caso contrario se lanza una excepción out_of_range (§5 ).

Ejemplo:

bs2.flip(5);

Devuelve un entero sin signo con el valor del patrón de bits almacenado en el contenedor. Si este valor no puede ser representado por un unsigned long, se lanza una excepción overflow_error (§5 ).  En cierta forma este método realiza la operación inversa del constructor C-2 .

Ejemplo:

bitset<125> bs2(64312UL);
cout << bs2.to_ulong() << endl;   // -> 64312 

Este método devuelve un string de N caracteres que corresponden con los bits del bitset. Cada carácter del string es '1' o '0' según el valor del bit correspondiente. viene determinado por el valor de la posición de su bit correspondiente.

La posición de los caracteres del string es la imagen especular de los bits del bitset; en el sentido que el carácter de posición 0 corresponde con el bit de posición N-1, y el carácter N-1 corresponde con el primer bit (pos 0). En cierta forma, este método realiza la operación inversa del constructor C-3 .

Debe advertirse que este método es una función genérica (plantilla) que no acepta argumentos, por lo que su utilización puede requerir una calificación explícita, ya que en determinadas condiciones el compilador no puede deducir los parámetros de plantilla necesarios. Ejemplo:

bitset<32> bs2(64312UL);
string s2 = bs2.to_string();   // L1:

puede ser necesario utilizar la sentencia L1 en la forma [3]:

string s2 = bs2.template to_string();

Ejemplo:

cout << bs2.to_string;

Aquí es necesario utilizar una instanciacion explicita, dado que el compilador es incapaz de deducirla del contexto (en nuestro caso deseamos una cadena de caracteres): 

cout << bs2.template to_string <char, char_traits<char>, allocator<char> >();

Ejemplo:

string s2 = bs2.to_string();
cout << "Imagen: " ;
for (string::iterator iT = s2.begin(); iT != s2.end(); iT++) cout << *iT;
cout << endl;

Salida:

Imagen: 00000000000000001111101100111000

Una forma más elegante para obtener la misma salida utilizando una instanciación explícita del método:

cout << "Imagen: " ;
bs2.template to_string <char, char_traits<char>, allocator<char> >();
cout << endl;

Nota: Observe el espacio entre los dos ángulos finales > >

Devuelve el número de elementos del objeto.

Ejemplo:

bitset<16> bs3;
bitset<16> bs4("10010101");
cout << "bs3 Contiene " << bs3.count() << " elementos\n";
cout << "bs4 Contiene " << bs4.count() << " elementos\n";

Salida:

bs3 Contiene 0 elementos
bs4 Contiene 4 elementos

Devuelve el tamaño del contenedor.

Ejemplo:

bitset<16> bs3;
cout << "bs3 puede contener " << bs3.size() << " elementos máximo\n";

Salida:

bs3 puede contener 16 elementos máximo 

Este método devuelve un booleano cierto/falso según el valor del bit de posición pos sea 1 o 0 respectivamente. El valor pos debe ser válido (estar dentro del rango aceptable para el bitset). En caso contrario se lanza una excepción out_of_range (§5 ).

Ejemplo:

bitset<8> bs4(string("00000011"));
cout << "Valor de bs4: " << bs4.to_ulong() << endl;
cout << "Elemento 0: " << (bs4.test(0)? "-1-": "-0-") << endl;
cout << "Elemento 8: " << (bs4.test(7)? "-1-": "-0-") << endl;

Salida:

Valor de bs4: 3
Elemento 0: -1-
Elemento 7: -0-

Este método devuelve un bool true si algún elemento del contenedor es 1. Falso en caso contrario.

Ejemplo:

bitset<8> bs4(string("00000011"));
cout << "Contiene algún 1?: " << (bs4.any()? "Cierto!!": "Falso!!") << endl;

Salida:

Contiene algún 1?: Cierto!!

Similar al anterior.  Devuelve un bool cierto si no contiene ningún 1. Falso en caso de contener alguno.

Ejemplo:

bitset<8> bs4(string("00000011"));
cout << "Contiene algún 1?: " << (bs4.none()? "Cierto!!": "Falso!!") << endl;

Salida:

Contiene algún 1?: Falso!!