You are on page 1of 2

República Bolivariana de Venezuela

Universidad Nacional Experimental Marítima del Caribe (UMC)


Coord. Ciencias Aplicadas – Ingeniería Marítima
Informática I – Prof. Lucía Santeramo

OPERADORES BINARIOS EN C++


C++ dispone de 6 operadores para manejo de bits que realizan dos tipos de operaciones:

• ( ~ ) Complemento a uno
• ( << ) Desplazamiento a izquierda
• ( >> ) Desplazamiento a derecha
• ( & ) AND, compara dos bits
• ( ^ ) XOR (OR exclusivo), compara dos bits
• ( | ) OR inclusivo, compara dos bits

( ~ ) Complemento a uno. Sintaxis: ~cast-expresion. Este operador unitario invierte cada bit del operando. 0 es
convertido en 1 y viceversa.

Representación binaria Invertido Proceso Resultado


0 = = 0000 0000 ~ 0 = = 1111 1111 -1 = = 1111 1110 + 0000 0001 = = 1111 1111 ~ 0 = = -1
1 = = 0000 0001 ~ 1 = = 1111 1110 -2 = = 1111 1101 + 0000 0001 = = 1111 1110 ~ 1 = = -2
2 = = 0000 0010 ~ 2 = = 1111 1101 -3 = = 1111 1100 + 0000 0001 = = 1111 1101 ~ 2 = = -3

#include <iostream.h>

short signed cero = 0, uno = 1, dos = 2;

int main (void) {


cout << "~0 == " << ~cero << endl;
cout << "~1 == " << ~uno << endl;
cout << "~2 == " << ~dos << endl; }

( << ) Desplazamiento a izquierda. Sintaxis: expr-desplazada << expr-desplazamiento. Este operador binario realiza un
desplazamiento de bits a la izquierda. El bit más significativo (más a la izquierda) se pierde, y se le asigna un 0 al menos
significativo (el de la derecha). El operando derecho indica el número de desplazamientos que se realizarán. Los
desplazamientos no son rotaciones, los bits que salen por la izquierda se pierden, los que entran por la derecha se
rellenan con ceros. Este tipo de desplazamientos se denominan lógicos en contraposición a los cíclicos o rotacionales.
#include <iostream.h>
0 == 0000 0000 0 << 1 == 0000 0000 == 0 short signed cero = 0, uno = 1, dos = 2;
1 == 0000 0001 1 << 1 == 0000 0010 == 2 int main (void) {
2 == 0000 0010 2 << 1 == 0000 0100 == 4 cout << "0 << 1 == " << (cero << 1) << endl;
cout << "1 << 1 == " << (uno<< 1) << endl;
-3 == 1111 1101 -3 << 1 == 1111 1010 ==-6
cout << "2 << 1 == " << (dos << 1) << endl; }

( >> ) Desplazamiento a derecha. Sintaxis: expr-desplazada >> expr-desplazamiento. El patrón de bits de expr-
desplazada sufre un desplazamiento derecho del valor indicado por la expr-desplazamiento. Como en el caso anterior,
ambos operandos deben ser números enteros o enumeraciones. En caso contrario, el compilador realiza una conversión
automática de tipo. El resultado es del tipo del primer operando. Una vez promovida a entero, expr-desplazamiento debe
ser un entero positivo y menor que la longitud del primer operando. En caso contrario, el resultado es indefinido
(depende de la implementación). El bit menos significativo (a la derecha) se pierde, pero hay que advertir que si expr-
desplazada es un entero con signo y es negativo, el resultado depende de la implementación.
#include <iostream.h>
0 = = 0000 0000 0 >>1 = = 0000 0000 = = 0 short signed cero = 0, dos = 2, mdos = -2;
2 = = 0000 0010 2 >> 1 = = 0000 0001 = = 1 int main (void) {
-2 = = 1111 1110 -2 >> 1 = = 1111 1111 = = -1 cout << "0 >> 1 == " << (cero >> 1) << endl;
cout << "2 >> 1 == " << (dos >> 1) << endl;
-16 = = 1111 0000 -16 >> 2 = = 1111 1100 = = -4
cout << "-2 >> 1 == " << (mdos >> 1) << endl; }
( & ) AND, compara dos bits. Sintaxis. AND-expresion & equality-expresion. Este operador binario compara ambos
operandos bit a bit, y como resultado devuelve un valor construido de tal forma que cada bits es 1 si los bits
correspondientes de los operandos están a 1. En caso contrario devuelve 0.

2 == 0000 0010 #include <iostream.h>


int main (void) {
-2 == 1111 1110 cout << "2 & -2 == " << (2 & -2) << endl;}
------------------
0000 0010 = = 2

( ^ ) XOR (OR exclusivo), compara dos bits. Sintaxis: expr-OR-exclusiva ^ AND-expresion. El funcionamiento de este
operador binario es parecido al AND lógico, salvo que en este caso el resultado es 1 si ambos bits son complementarios
(uno es 0 y el otro 1). En caso contrario devuelve 0.

7 = = 0000 0111 #include <iostream.h>


-2 = = 1111 1110 int main (void) {
------------------ cout << "7 ^ -2 == " << (7 ^ -2) << endl;}
1111 1001 = = -7

( | ) OR inclusivo, compara dos bits. Sintaxis: expr-OR-inclusiva | expr-OR-exclusiva. Este operador binario tiene un
funcionamiento parecido a los anteriores (AND y XOR), salvo que en este caso el resultado es 1 si alguno de ellos está a
1. En caso contrario devuelve 0.

6 = = 0000 0110 #include <iostream.h>


13 = = 0000 1101 int main (void) {
------------------ cout << "6 | 13 == " << (6 | 13) << endl;}
0000 1111 = = 15

Asignaciones compuestas con operadores de bits. Salvo el complemento a uno (~) que es unitario, los demás operadores de
menejo de bits pueden combinarse con la asignación simple (=) para dar lugar a una asignación compuesta.
#include <iostream.h>
x &= y; // equivale a: x = (x & y); int main() {
x ^=y; // equivale a: x = (x ^ y); signed int x = 2, y = 7, z = 6, a = 2, b= -2;
x |= y; // equivale a: x = (x | y); x &= -2;
y ^= -2;
x <<= y; // equivale a: x = (x << y); z |= 13;
x >>= y; // equivale a: x = (x >> y); a <<= 1;
b >>= 1;
cout << "Valor x = " << x << endl << "Valor y = " << y << endl;
cout << "Valor z = " << z << ende << "Valor a = " << a << endl;
cout << "Valor b = " << b <<endl; }

Cuadro sinóptico con los resultados de aplicar los operadores AND, XOR y OR entre dos enteros característicos (los
valores 0 y 1):

A B A& B A^ B A|B
0 0 0 0 0
1 0 0 1 1
0 1 0 1 1
1 1 1 0 1

You might also like