Un conjunto de bits es una array de bool, pero cada valor booleano no se almacena por separado, sino que el conjunto de bits optimiza el espacio de modo que cada bool ocupa solo 1 bit de espacio, por lo que el espacio ocupado por el conjunto de bits bs es menor que el del bool bs[N] y el vector bs( N) . Sin embargo, una limitación del conjunto de bits es que N debe conocerse en el momento de la compilación, es decir, una constante (esta limitación no existe con el vector y la array dinámica)
Como el conjunto de bits almacena la misma información de forma comprimida, la operación en el conjunto de bits es más rápida que la de la array y el vector. Podemos acceder a cada bit del conjunto de bits individualmente con la ayuda del operador de indexación de array [] que es bs[3] muestra el bit en el índice 3 del conjunto de bits bs como una array simple. Recuerde que el conjunto de bits comienza su indexación hacia atrás, es decir, para 10110, 0 está en los índices 0 y 3, mientras que 1 está en los índices 1, 2 y 4.
Podemos construir un conjunto de bits utilizando un número entero, así como una string binaria a través de constructores que se muestran en el código a continuación. El tamaño del conjunto de bits se fija en tiempo de compilación, es decir, no se puede cambiar en tiempo de ejecución.
La función principal definida para la clase de conjunto de bits es operador [], conteo, tamaño, configuración, reinicio y muchas más, se explican en el siguiente código:
// C++ program to demonstrate various functionality of bitset
#include <bits/stdc++.h>
using namespace std;
#define M 32
int main()
{
// default constructor initializes with all bits 0
bitset<M> bset1;
// bset2 is initialized with bits of 20
bitset<M> bset2(20);
// bset3 is initialized with bits of specified binary string
bitset<M> bset3(string("1100"));
// cout prints exact bits representation of bitset
cout << bset1 << endl; // 00000000000000000000000000000000
cout << bset2 << endl; // 00000000000000000000000000010100
cout << bset3 << endl; // 00000000000000000000000000001100
cout << endl;
// declaring set8 with capacity of 8 bits
bitset<8> set8; // 00000000
// setting first bit (or 6th index)
set8[1] = 1; // 00000010
set8[4] = set8[1]; // 00010010
cout << set8 << endl;
// count function returns number of set bits in bitset
int numberof1 = set8.count();
// size function returns total number of bits in bitset
// so there difference will give us number of unset(0)
// bits in bitset
int numberof0 = set8.size() - numberof1;
cout << set8 << " has " << numberof1 << " ones and "
<< numberof0 << " zeros\n";
// test function return 1 if bit is set else returns 0
cout << "bool representation of " << set8 << " : ";
for (int i = 0; i < set8.size(); i++)
cout << set8.test(i) << " ";
cout << endl;
// any function returns true, if atleast 1 bit
// is set
if (!set8.any())
cout << "set8 has no bit set.\n";
if (!bset1.any())
cout << "bset1 has no bit set.\n";
// none function returns true, if none of the bit
// is set
if (!bset1.none())
cout << "bset1 has some bit set\n";
// bset.set() sets all bits
cout << set8.set() << endl;
// bset.set(pos, b) makes bset[pos] = b
cout << set8.set(4, 0) << endl;
// bset.set(pos) makes bset[pos] = 1 i.e. default
// is 1
cout << set8.set(4) << endl;
// reset function makes all bits 0
cout << set8.reset(2) << endl;
cout << set8.reset() << endl;
// flip function flips all bits i.e. 1 <-> 0
// and 0 <-> 1
cout << set8.flip(2) << endl;
cout << set8.flip() << endl;
// Converting decimal number to binary by using bitset
int num = 100;
cout << "\nDecimal number: " << num
<< " Binary equivalent: " << bitset<8>(num);
return 0;
}
Producción :
00000000000000000000000000000000 00000000000000000000000000010100 00000000000000000000000000001100 00010010 00010010 has 2 ones and 6 zeros bool representation of 00010010 : 0 1 0 0 1 0 0 0 bset1 has no bit set. 11111111 11101111 11111111 11111011 00000000 00000100 11111011 Decimal number: 100 Binary equivalent: 01100100
Para el conjunto de bits, se definen las funciones de reinicio y volteo. La función Set establece (1) todos los bits del conjunto de bits si no se proporciona ningún argumento; de lo contrario, establece el bit cuya posición se proporciona como argumento. De la misma manera, restablecer y voltear también funcionan si se les llama sin argumento, realizan su operación en todo el conjunto de bits y si se proporciona alguna posición como argumento, realizan la operación solo en esa posición.
Para el conjunto de bits, todos los operadores bit a bit están sobrecargados, es decir, se pueden aplicar al conjunto de bits directamente sin ningún tipo de conversión o conversión, los principales operadores sobrecargados son &, |, ==, != y el operador de desplazamiento <> que facilita la operación en el conjunto de bits.
El uso del operador anterior se muestra en el siguiente código.
// C++ program to show applicable operator on bitset.
#include <bits/stdc++.h>
using namespace std;
int main()
{
bitset<4> bset1(9); // bset1 contains 1001
bitset<4> bset2(3); // bset2 contains 0011
// comparison operator
cout << (bset1 == bset2) << endl; // false 0
cout << (bset1 != bset2) << endl; // true 1
// bitwise operation and assignment
cout << (bset1 ^= bset2) << endl; // 1010
cout << (bset1 &= bset2) << endl; // 0010
cout << (bset1 |= bset2) << endl; // 0011
// left and right shifting
cout << (bset1 <<= 2) << endl; // 1100
cout << (bset1 >>= 1) << endl; // 0110
// not operator
cout << (~bset2) << endl; // 1100
// bitwise operator
cout << (bset1 & bset2) << endl; // 0010
cout << (bset1 | bset2) << endl; // 0111
cout << (bset1 ^ bset2) << endl; // 0101
}
Producción :
0 1 1010 0010 0011 1100 0110 1100 0010 0111 0101
Este artículo es una contribución de Utkarsh Trivedi. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA