Foro de elhacker.net

Un byte son 8 bits, 1 bit es 1 o 0, pero como se usan y para que sirven los Operadores de bits

(https://gyazo.com/ebff5d4df4cad4485766227ff9607191)

Como se usan estos operadores ??

Lo he leído muchas veces y he echo los ejercicios para practicar en esta página pero no tengo ni idea de lo que hacen.

Aquí un ejemplo que pone con el operador (OR) por ejemplo:

#include <stdio.h>
 
int main(){
	printf( "El resultado de la operación 235 | 143 es: %i\n", 235 | 143 );
}
 
 

uno de los usos basicos en linux es por ejemplo la seguridad de los archivos


1 = lectura (001)
2 = escritura (010)
4 = ejecución (100)

así que

if(seguridad & b001) printf("lectura");
if(seguridad & b010) printf("escritura");
if(seguridad & b100) printf("ejecución")

la cosa es que si el archivo tiene seguridad 3 (b011) es lectura y escritura

podrías usarlo para imprimir los archivos en binario

while(numero > 0){
  if(numero & 1){
    printf("1");
  }else{
    printf("0");
  }
  numero = numero >> 1;
}

se usa para tambien para cifrar archivos... el más simple es el cifrado xor ya que es una operacion reversible (si se hace, al hacerlo nuevamente vuelve a tener el contenido original)

tiene infinitos usos... la cosa es conseguir cuando lo necesitas

En Windows, es muy común usar estos operadores para crear flags. Me explico: Al crear una ventana, tu le tienes que pasar una serie de caracteristicas a dicha ventana (por ejemplo, ¿tendrá borde mi ventana?, ¿será en pantalla completa?, etc). Para pasarle estas propiedades a Windows, se usan los ya mencionados, los Flags (en español banderas)

Agunas propiedades son:
WS_VISIBLE = 10000000000000000000000000000 en binario (Define si una ventana es visible)
WS_VSCROLL= 00000001000000000000000000000 en binario (Define si una ventana tendrá una barra de desplazamiento vertical)

Entonces, si le quieres pasar esos dos parametros juntos a Windows, haces lo siguiente:

WS_VISIBLE | WS_VSCROLL, lo cual dará como resultado:
10000001000000000000000000000

Como ves, hemos conseguido fusionar las dos propiedades en una sin perder información.

Espero que se haya entendido

Pero no son dos cosas totalmente diferentes? Es decir no proceso ahora mismo esa información,

 10000000000000000000000000000 es una cosa

y 00000001000000000000000000000 otra, como puede ser que se conviertan en un número binario para los dos?¿

Mira, imagínate que asignamos a dos propiedades diferentes dos ID diferentes:
*A la propiedad de que la ventana debe estar en pantalla completa le asignamos la ID 01 (Está en binario)
*A la propiedad de que la ventana tenga bordes le asignamos la ID 10.

Entonces, si le pasamos la propiedad de pantalla completa solamente, le pasaremos 01. Si le pasamos solamente la propiedad de que la ventana tenga bordes, le pasamos 10, y si queremos que tenga ambas propiedades, le pasamos 01 | 10, es decir, 11.

Dicho de otra forma, a cada propiedad le asignamos una posición en una variable. En el caso anterior, solamente caben 2 propiedades como máximo, puesto que solo hay dos posiciones, es decir, 2 bits. A la posicion 1 le asigné la propiedad de pantalla completa, si vale 0, entonces estará en modo ventana y si vale 1 estará en pantalla completa, y lo mismo con la ventana con bordes. Si la segunda posición vale 0, entonces la ventana no tendrá bordes, y viceversa.

Además, si te sirve de algo, los operadores binarios, son eso, para hacer operaciones binarias. Esa es su utilidad obvia y real. Claro que pocas utilidades tiene eso hoy en día. por eso su utilización se suele limitar a lo que comentan engel lex y RockPosts.

Vale... entiendo que se hace así pero no entiendo la lógica...

Lo interesante de las operaciones binarias AND, OR y NOT, es que trabajan con números como si se tratasen de arreglos de datos niarios (true/false).
Mira este ejemplo:

// [0] = LECTURA, [1] = ESCRITURA, [2] = MODO_BINARIO, [3] = TRUNCAR
char *flags = "0000";
flags[0] = '1'; // LECTURA activado
 
if(flags[0] == '1')
    printf("Modo lectura activado");

Hasta ahí bien, ¿no?

Ahora, imagínate que en vez de necesitar 8 bytes para guardar 4 valores, pudieses guardar 32 valores en solo 4 bytes (32 bits).
Es muy parecido:

// 0b1000 = LECTURA, 0b0100 = ESCRITURA, 0b0010 = MODO_BINARIO, 0b0001 = TRUNCAR
int flags = 0;
flags = flags | 0b1000; // LECTURA activado
 
if(flags & 0b1000 != 0)
    printf("Modo lectura activado");

El resto, ya depende de tu conocimiento de operaciones con números binarios.

Mmmm no, lo siento.

Voy ha preguntarte algunas cosas que no se que son y así seguramente entenderé el código:

Por ejemplo:

char *flags = "0000";

Que significa "*flags  y porque le pones un asterico , también he visto que en algunos " char " pones un asterisco también por qué?

*char 

O aveces con dos "**".

Porque pones los "[]" en un flag?, por intuición creo que es un array...
 
y en el array pones entre comas el 1 por ejemplo " '1' ".

Aun andas muy verde en C xD
* es un puntero. char* es un puntero a char.

"abc" es una cadena de char (char*).
'a' es un char.

flags[0] es el char de índice 0. Para asignarle un valor, le pongo '1' (el caracter '1', 49 en ascii)

No usarás operadores a nivel de bit hasta que avances más en C, así que si aun no lo comprendes bien, no hay problema en que lo dejes para más adelante.

Me parece buena opción jaja xD