¿Cuáles son las diferencias entre los operadores AND lógicos y bit a bit en C/C++?

Un operador Bitwise And se representa como ‘&’ y un operador lógico se representa como ‘&&’. Las siguientes son algunas diferencias básicas entre los dos operadores.

a) El operador lógico y ‘&&’ espera que sus operandos sean expresiones booleanas (ya sea 1 o 0) y devuelve un valor booleano. 
El bit a bit y el operador ‘&’ funcionan en valores Integrales (short, int, unsigned, char, bool, unsigned char, long) y devuelven el valor Integral. 

#include<iostream>
using namespace std;
int main()
{
    int x = 3;  //...0011
    int y = 7;  //...0111
 
    // A typical use of '&&'
    if (y > 1 && y > x)
      cout<<"y is greater than 1 AND x\n";
 
    // A typical use of '&'
    int z = x & y;   // 0011
    
    cout<<"z = "<< z;
 
    return 0;
}
 
// this code is contributed by shivanisinghss2110

#include<stdio.h>
int main()
{
    int x = 3;  //...0011
    int y = 7;  //...0111
 
    // A typical use of '&&'
    if (y > 1 && y > x)
      printf("y is greater than 1 AND x\n");
 
    // A typical use of '&'
    int z = x & y;   // 0011
    
    printf ("z = %d", z);
 
    return 0;
}

y is greater than 1 AND x
z = 3

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)

b) Si se usa un valor integral como operando para ‘&&’ que se supone que funciona en valores booleanos, se usa la siguiente regla en C. 
…..Cero se considera falso y distinto de cero se considera verdadero. 

Por ejemplo, en el siguiente programa, x e y se consideran como 1.  

#include<iostream>
using namespace std;
 
// Example that uses non-boolean expression as
// operand for '&&'
int main()
{
   int x = 2, y = 5;
   cout<<" "<< x&&y;
   return 0;
}
 
//this code is contributed by shivanisinghss2110

#include<stdio.h>
// Example that uses non-boolean expression as
// operand for '&&'
int main()
{
   int x = 2, y = 5;
   printf("%d", x&&y);
   return 0;
}

1

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)

Es un error del compilador usar la expresión no integral como operando para bit a bit &. Por ejemplo, el siguiente programa muestra un error del compilador. 

#include<stdio.h>
// Example that uses non-integral expression as
// operator for '&'
int main()
{
   float x = 2.0, y = 5.0;
   printf("%d", x&y);
   return 0;
}

Producción: 

error: invalid operands to binary & (have 'float' and 'float')

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)

c) El operador ‘&&’ no evalúa el segundo operando si el primer operando se vuelve falso. Del mismo modo ‘||’ no evalúa el segundo operando cuando el primer operando se vuelve verdadero. El bit a bit ‘&’ y ‘|’ los operadores siempre evalúan sus operandos. 

#include <iostream>
using namespace std;
int main()
{
    int x = 0;
 
    // 'Geeks in &&' is NOT
    // printed because x is 0
    printf("%d\n", (x && printf("Geeks in && ")));
 
    // 'Geeks in &' is  printed
    printf("%d\n", (x & printf("Geeks in & ")));
 
    return 0;
}
//this code is contributed by aditya942003patil

#include<stdio.h>
int main()
{
    int x = 0;
 
    // 'Geeks in &&' is NOT
    // printed because x is 0
    printf("%d\n", (x && printf("Geeks in && ")));
 
    // 'Geeks in &' is  printed
    printf("%d\n", (x & printf("Geeks in & ")));
 
    return 0;
}

0
Geeks in & 0

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)

Las mismas diferencias existen entre OR lógico ‘||’ y bit a bit O ‘|’.

Este artículo es una contribución de Ujjwal Jain . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.