elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recopilación Tutoriales y Manuales Hacking, Seguridad, Privacidad, Hardware, etc


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Operadores a nivel de bits (lenguaje C). 		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] 2 Ir Abajo Respuesta Imprimir
Autor Tema: Operadores a nivel de bits (lenguaje C).  (Leído 9,397 veces)
NOB2014


Desconectado Desconectado

Mensajes: 366



Ver Perfil
Operadores a nivel de bits (lenguaje C).
« en: 16 Marzo 2014, 02:48 am »
Hola a todos.
Estoy estudiando “Operadores a nivel de bits” y no sólo deseo aprender la sintaxis sino también interpretar lo que hace cada línea de código.-

Lenguaje: “C”

Problema: (dudas) Expuesta en el código. 
                                                                                 
Error: Ninguno.

Otras Observaciones: Ninguna.

Código:

Código
  1. # include <stdio.h>
  2.  
  3. void despriegaBits(unsigned valor);
  4.  
  5. int main(void){
  6. 	unsigned x; //No entiendo esta declaracion de variable, cual es el tipo?
  7. 	printf("\n\n Introduzca un entero sin signo....:");
  8. 	scanf("%u", &x);
  9.  
  10. 	despriegaBits(x);
  11.  
  12. 	return 0;
  13. }
  14.  
  15. void despriegaBits(unsigned valor){
  16. 	unsigned c; //No entiendo esta declaracion de variable, cual es el tipo?
  17.  
  18. 	unsigned despliegaMascara = 1 << 31; //Esta sentencia como se llama?, pareceria una funcion, pero no
  19.                                              //tiene parentesis, me desconcierta, y lo mas importante, como funciona?, que hace?. 
  20.  
  21. 	printf("\n %10u = ", valor);
  22.  
  23. 	for(c = 1; c <=	32; c++){
  24. 		putchar(valor & despliegaMascara ? '1' : '0');
  25. 		valor <<= 1;
  26.  
  27. 		if(c % 8 == 0){
  28. 			putchar(' ');
  29. 		}
  30. 	}
  31. 	putchar('\n');
  32. }

Desde ya muchas gracias por la ayuda que puedan brindarnos.-
Saludos.
Daniel
En línea
abraza las cosas y personas malas como si fueran tu mas preciada joya,Son tus mas grandes maestros de paciencia sabiduría y amor y cuando lo abrazas dejan de causar dolor.-
engel lex
Moderador Global
***
Desconectado Desconectado

Mensajes: 15.514



Ver Perfil
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #1 en: 16 Marzo 2014, 02:57 am »
"unsigned" es una forma corta de "unsigned int" que es entero sin signo (solo positivos)

Código:
despliegaMascara = 1 << 31;

el >> y << sirven para mover un bit a la derecha o izquierda...

se usan igual que los operadores aritmeticos (a = 1 + 2)

se toma 1 en binario (que es igual 1) y se mueve 31 veces a la izquierda

Código:
1
10
100
1000
------
100000000000000000000000000000000
el valor en entero de esa variable no es importante en este caso... ya que se usará para una comparación en binario...

alguna otra duda?


por cierto! te llevas una buena cantidad de puntos por hacer un post bien explicado y con platilla y todo XD
En línea
El problema con la sociedad actualmente radica en que todos creen que tienen el derecho de tener una opinión, y que esa opinión sea validada por todos, cuando lo correcto es que todos tengan derecho a una opinión, siempre y cuando esa opinión pueda ser ignorada, cuestionada, e incluso ser sujeta a burla, particularmente cuando no tiene sentido alguno.
NOB2014


Desconectado Desconectado

Mensajes: 366



Ver Perfil
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #2 en: 16 Marzo 2014, 03:34 am »
Hola angelx.
Sí, me quedan dudas sobre tu explicación, no porque este mal hecha( todo lo contrario) solo que siempre tardo en que me caiga la ficha, cuando esto ocurra los volveré a consultar.-

Saludos.
Daniel
En línea
abraza las cosas y personas malas como si fueran tu mas preciada joya,Son tus mas grandes maestros de paciencia sabiduría y amor y cuando lo abrazas dejan de causar dolor.-
engel lex
Moderador Global
***
Desconectado Desconectado

Mensajes: 15.514



Ver Perfil
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #3 en: 16 Marzo 2014, 03:58 am »
ok ;) no hoy problema... de toda formas dejo unos datos más


Código:
paso a paso las operaciones serían
a = 5 << 6;

      101
     1010
    10100
   101000
  1010000
 10100000
101000000

resultado: a -> B101000000 (B por binario)
---------------------------------------
a = 84 >> 3;
1010100
 101010
  10101
   1010

resultado: a->B1010 
en este segundo caso los bits mas bajos simplemente desaparecen
---------------------------------------
a = 5;
a =<< 3; (esta expresion es similar a decir a = a<<3)
   101
  1010
 10100
resultado: a->B10100 
---------------------------------------
a = 5 & 3
esto es un and lógico normal
101
011
___
001
resultado: a->1
---------------------------------------
a = 86 | 34
esto es un or lógico inclusivo
1010110
 100010
_______
1110110
resultado: a->B1110110
---------------------------------------
a = 86 ^ 34
esto es un or lógico exclusivo (o xor)
1010110
 100010
_______
1110100
resultado: a->B1110100



ahí tienes operadores binarios y su uso :P
En línea
El problema con la sociedad actualmente radica en que todos creen que tienen el derecho de tener una opinión, y que esa opinión sea validada por todos, cuando lo correcto es que todos tengan derecho a una opinión, siempre y cuando esa opinión pueda ser ignorada, cuestionada, e incluso ser sujeta a burla, particularmente cuando no tiene sentido alguno.
rir3760


Desconectado Desconectado

Mensajes: 1.639


Ver Perfil
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #4 en: 16 Marzo 2014, 15:10 pm »
Un problema con ese programa es asumir que el tipo unsigned int esta constituido por 32 bits (si son mas el resultado es incorrecto, si son menos el programa reventara por el desplazamiento).

Una mejor aproximación consiste en utilizar el operador sizeof para obtener el numero de bytes y la macro CHAR_BIT para el numero de bits:
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4.  
  5. void imprimir(unsigned num);
  6.  
  7. int main(void)
  8. {
  9.    unsigned num;
  10.  
  11.    printf("Introduce un entero no negativo: ");
  12.    fflush(stdout);
  13.    if (scanf("%u", &num) != 1)
  14.       return EXIT_FAILURE;
  15.  
  16.    imprimir(num);
  17.  
  18.    return EXIT_SUCCESS;
  19. }
  20.  
  21. void imprimir(unsigned num)
  22. {
  23.    unsigned msb = 1U << sizeof(unsigned) * CHAR_BIT - 1;
  24.    size_t i;
  25.    size_t j;
  26.  
  27.    for (i = 0; i < sizeof(unsigned); i++){
  28.       for (j = 0; j < CHAR_BIT; j++){
  29.          putchar(num & msb ? '1' : '0');
  30.          msb >>= 1;
  31.       }
  32.  
  33.       putchar(' ');
  34.    }
  35.    putchar('\n');
  36. }

Un saludo
En línea
C retains the basic philosophy that programmers know what they are doing; it only requires that they state their intentions explicitly.
--
Kernighan & Ritchie, The C programming language
ivancea96


Desconectado Desconectado

Mensajes: 3.412


ASMático


Ver Perfil WWW
Re:
« Respuesta #5 en: 16 Marzo 2014, 15:54 pm »
Si son menos, el programa no revienta, simplemente se pierden los bits :o

Enviado desde mi ST21i mediante Tapatalk
En línea
Code0x66 - Blog de hacking & programación
rir3760


Desconectado Desconectado

Mensajes: 1.639


Ver Perfil
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #6 en: 16 Marzo 2014, 16:20 pm »
Cita de: ivancea96 en 16 Marzo 2014, 15:54 pm
Cita de: rir3760 en 16 Marzo 2014, 15:10 pm
Un problema con ese programa es asumir que el tipo unsigned int esta constituido por 32 bits (si son mas el resultado es incorrecto, si son menos el programa reventara por el desplazamiento).

Si son menos, el programa no revienta, simplemente se pierden los bits
No (por el desplazamiento). Para explicarlo mejor considerando que el numero de iteraciones y el desplazamiento esta dado por "magic numbers":
Código
  1. unsigned despliegaMascara = 1 << 31;
  2.  
  3. /* ... */
  4.  
  5. for(c = 1; c <=	32; c++) ...

Si el numero de bits del tipo unsigned int es:
A) Mayor (por ejemplo 64) entonces solo se procesa una parte de los bits.
B) Menor (por ejemplo 16) entonces el desplazamiento "1 << 31" causara que el programa reviente ya que el segundo operando debe ser mayor que cero y menor que el numero de bits del objeto.

Un saludo
En línea
C retains the basic philosophy that programmers know what they are doing; it only requires that they state their intentions explicitly.
--
Kernighan & Ritchie, The C programming language
Yoel Alejandro

Desconectado Desconectado

Mensajes: 254



Ver Perfil WWW
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #7 en: 16 Marzo 2014, 17:15 pm »
¿Qué se quiere decir exactamente con que el programa "revienta"? ¿Fuga de memoria, terminación anormal?

Hice una prueba, tomé el unsigned 1 y fui desplazando sus bits a la izquierda e imprimiendo el resultado por bits (con las mismas funciones dadas aportadas en el tema), para observar lo que ocurre luego del desplazamiento número 31.

Para mayor seguridad mandé imprimir antes la cantidad de bits de la representación de enteros en mi máquina y verificar que son 32. El resultado del programa:

En esta maquina los enteros ocupan 32 bits
29: 00100000 00000000 00000000 00000000
30: 01000000 00000000 00000000 00000000
31: 10000000 00000000 00000000 00000000
32: 00000000 00000000 00000000 00000000
33: 00000000 00000000 00000000 00000000

Se aprecia que en los desplazamientos 32 en adelante simplemente se pierde el bit y el número queda compuesto por ceros, pero la consola no me indica terminacióna anormal. Consulté el estado de salida del proceso (echo $?, para bash) y fue 0 (normal).

¿Qué me dicen ustedes?

====================
(EDITO) Ya comprendí el dilema, creo que no estamos hablando de lo mismo. La instrucción "num << 31" tendrá un comportamiento indefinido (pero no un error fatal) si el operando a la derecha es mayor que la longitud en bits del operando a la izquierda. Lo que yo hice fue diferente, ejecutar "num << 1" reiterativamente más de 31 veces.
====================

Código
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <limits.h>
  4.  
  5. void imprimir(unsigned num);
  6.  
  7. int main( ) {
  8.  
  9.    unsigned num = 1;
  10.    int i;
  11.  
  12.    printf("En esta maquina los enteros ocupan %d bits\n",
  13.           sizeof(unsigned) * CHAR_BIT);
  14.  
  15.    for (i = 0; i < 34; num <<= 1, i++ )
  16.       if ( i > 28 ) {
  17.          printf( "%d: ", i );
  18.          imprimir( (unsigned) num );
  19.       }
  20.  
  21.    return 0;
  22. }
  23.  
  24. void imprimir(unsigned num)
  25. {
  26.    unsigned msb = 1U << sizeof(unsigned) * CHAR_BIT - 1;
  27.    size_t i;
  28.    size_t j;
  29.  
  30.    for (i = 0; i < sizeof(unsigned); i++) {
  31.       for (j = 0; j < CHAR_BIT; j++) {
  32.          putchar(num & msb ? '1' : '0');
  33.          msb >>= 1;
  34.       }
  35.       putchar(' ');
  36.    }
  37.    putchar('\n');
  38. }
« Última modificación: 16 Marzo 2014, 17:30 pm por yoel_alejandro » En línea
Saludos, Yoel.
P.D..-   Para mayores dudas, puedes enviarme un mensaje personal (M.P.)
NOB2014


Desconectado Desconectado

Mensajes: 366



Ver Perfil
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #8 en: 17 Marzo 2014, 00:27 am »
Hola a todos.
Gracias a , ivancea96,Rir3760,yoel_alejandro por la ayuda, me interesa el código de estos último dos que luego de debelar las dudas que expongo a continuación voy a correrlos y estudiarlos.-

Código
  1. unsigned despliegaMascara = 1 << 31;
engelx ¿me podrías decir cuál es el valor final de despliegaMascara?, no logro mostrarlo con un printf y mil disculpas por la ignoracia al suponer que podía ser una función.-

Código
  1. putchar(valor & despliegaMascara ? '1' : '0');
En esta línea valor en cada iteración se mueve un bits a la izquierda ¿ con despliegaMascara no debería pasar lo mismo ?.-

Demás esta aclarar que la ayuda de cualquiera es bienvenida.-

Saludos.
Daniel 
En línea
abraza las cosas y personas malas como si fueran tu mas preciada joya,Son tus mas grandes maestros de paciencia sabiduría y amor y cuando lo abrazas dejan de causar dolor.-
engel lex
Moderador Global
***
Desconectado Desconectado

Mensajes: 15.514



Ver Perfil
Re: Operadores a nivel de bits (lenguaje C).
« Respuesta #9 en: 17 Marzo 2014, 00:59 am »
Citar
engelx ¿me podrías decir cuál es el valor final de despliegaMascara?
teoricamente el valor es 2147483648 pero eso no es lo importante, solo importa como binario...

despliegue mascara vale en binario
100000000000000000000000000000000


Citar
En esta línea valor en cada iteración se mueve un bits a la izquierda ¿ con despliegaMascara no debería pasar lo mismo ?

no despliegaMascara es simplemente para comprobar si hay un 1 en el bit más a la izquierda
por ejemplo con el numero 5

Código:
despliegueMascara = 100000000000000000000000000000000
5 en binario = 101
c= 1
100000000000000000000000000000000
000000000000000000000000000000101
recordando que esto es un and esto igual a 0...
 asi que simplemente colocaré varios pasos

c= 2
100000000000000000000000000000000
000000000000000000000000000001010 = 0

c= 3
100000000000000000000000000000000
000000000000000000000000000010100 = 0
.........
c= 29
100000000000000000000000000000000
010100000000000000000000000000000 = 0

c= 30
100000000000000000000000000000000
101000000000000000000000000000000 !=0 esto imprime un 1

c= 31
100000000000000000000000000000000
010000000000000000000000000000000 = 0

c= 32
100000000000000000000000000000000
100000000000000000000000000000000 !=0 esto imprime un 1

sabras que "?" es un if resumido

Código
  1. putchar(valor & despliegaMascara ? '1' : '0');

es lo mismo que
Código
  1. if(valor & despliegaMascara){
  2.     putchar('1');
  3. }else{
  4.     putchar('0');
  5. }
En línea
El problema con la sociedad actualmente radica en que todos creen que tienen el derecho de tener una opinión, y que esa opinión sea validada por todos, cuando lo correcto es que todos tengan derecho a una opinión, siempre y cuando esa opinión pueda ser ignorada, cuestionada, e incluso ser sujeta a burla, particularmente cuando no tiene sentido alguno.
Páginas: [1] 2 Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda, operadores a nivel bit?
PHP 		HardieVon 3 2,410 Último mensaje 19 Febrero 2009, 05:55 am
por HardieVon
[Python] Duda de Operadores a nivel bit [Not(~)]
Scripting 		evocal 1 4,073 Último mensaje 25 Noviembre 2012, 00:03 am
por Danyfirex
De minúscula a mayúscula a nivel de bits en lenguaje C. « 1 2 3 4 »
Programación C/C++ 		DanielPy 32 15,897 Último mensaje 4 Enero 2014, 19:12 pm
por leosansan
De minúscula a mayúscula a nivel de bits (lenguaje C.)
Programación C/C++ 		NOB2014 4 3,607 Último mensaje 21 Marzo 2014, 02:44 am
por rir3760
Los operadores podrán bloquear el nivel de cobertura en Android P
Noticias 		wolfbcn 1 1,553 Último mensaje 25 Diciembre 2017, 23:31 pm
por Serapis
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines