Leer número entero en binario

[Gedeon]

Hola
Si yo quiero leer una longitud en un ficheo binario y me dicen que está en cuatro bits ¿Como hago para interpretar esos cuatro bits?

Pongamos un ejemplo de cuatro bits (valores en decimal)
bit 0: 0
bit 1: 0
bit 2: 1
bit 3: 1

¿Para saber esa longitud debo sumar byte 1+byte 2+ byte 3+ byte 4? En este caso 0+0+1+1=2
¿Debo considerar sus posiciones como bits de mayor peso? (en binario
bit 0: 00000000
bit 1: 00000000
bit 2: 00000001
bit 3: 00000001
En este caso habría que evaluar 00000000000000000000000100000001
que obviamente no es 2.
¿hay alguna otra alternativa que se me escapa?

[benekid]

Aqui tienes una posible solucion....
Solo te suma numeros predefinidos, pero no te costará mucho adaptarlo a sumas complejas! ;)

Saludos

Código:

//Programa que suma dos numeros binarios. Se tiene en cuenta el overflow y con un maximo de 6 bits.
//Autores: Carlos Beneyto y Santi Alex

#include <stdio.h>

int vector_resultado[7];
int vector1[7]={0,0,0,0,1,0,1};
int vector2[7]={0,0,0,0,1,0,1};
int acarreo=0, i;               //Variable de Acarreo, suma el acarreo en el siguiente digito

main()
{

printf("Sumar dos numeros binarios 5 (000101)\n");
printf("\t\n000101");
printf("\t\n+");
printf("\t\n000101");
printf("\t\n-------\n");

/*Bucle que recorre el vector, sumando digito a digito, desde el ultimo numero del vector,
pues la suma se hace de derecha a izquierda, para tener en cuenta el acarreo*/
for(i=6; i>=0; i--)
  {

 //Acarreo: Cambia el valor del resultado, sumando el acarreo en el siguiente valor.
  vector_resultado[i]=vector_resultado[i]+acarreo;
  acarreo=0;

  vector_resultado[i]=vector1[i]+vector2[i]+vector_resultado[i];

  //Si el resultado es la suma de 1+1, cambia el resultado a 0 y cambia la veriable acarreo a 1.
  if(vector_resultado[i]==2) { vector_resultado[i]=0; acarreo=1; }
    }

  //En caso de que haya overflow, escribe el numero en 7 bits
if(vector1[1] && vector2[1] == 1) {
    printf("\n(!) Hay Overflow, el resultado es de 7 bits\n\n");
        printf("%d%d%d%d%d%d%d", vector_resultado[0],vector_resultado[1],vector_resultado[2],vector_resultado[3],vector_resultado[4],vector_resultado[5],vector_resultado[6]);
    printf("\n\n");
}
else {
    printf("%d%d%d%d%d%d", vector_resultado[1],vector_resultado[2],vector_resultado[3],vector_resultado[4],vector_resultado[5],vector_resultado[6]);
    printf("\n\n");
}

}

[Gedeon]

Gracias por la molestia pero no es eso lo que se preguntaba.

La pregunta es como se lee un número entero que ocupa mas de un byte en un fichero binario para interpretarlo bien.

Pongamos que en un fichero binario hay una zona de cuatro bytes para almacenar una longitud. Esa longitud puede ser 1, 200, 500 ó 16.000, lo que quepa en cuatro bytes.

Yo tengo que leer esos cuatro bytes y obtener la longitud. lo que leo en esos bytes es (en decimal)
0
2
102
185
¿Cual es la longitud? ¿Los sumo? los leo de izquierda a derecha? ¿De Derecha a Izquierda? ¿Alguna otra cosa?

[Megamouse]

Como estas leyendo esos datos del fichero? dependiendo de como lo hagas la manera de transformar ese dato cambia.

Lo que siempre es igual es si tienes 4 bytes:

a[0] = 0000 0000 -> 0 0 -> 0
a[1] = 0000 0010 -> 0 2 -> 2
a[2] = 0110 0110 -> 6 6 -> 102
a[3] = 1011 1001 -> B 9 -> 185

el numero resultante es 00 02 66 B9 (lo pongo en hex porque es mas comodo) o lo que es lo mismo:

(a[0]*256*256*256)+(a[1]*256*256)+(a[2]*256)+a[3]

Código C:

int main (void)
{
  unsigned int tam;
  char a[4];
  int i;
 
  a[0]=0; a[1]=2; a[2]=102; a[3]=185;
  
  tam= 0;
  for (i=0; i<4; i++)
    tam= (tam << 8) + a[i];
  
  printf ("Tam file: [%d]\n", tam);
  getch();
  return 0;
}
 

Aunque se podria leer directamente del fichero binario:

Código C:

read (fd, &tam, 4);
 

tam debe poder almacenar 4 bytes (habitualmente un int)

[Gedeon]

Muchas gracias. Eso es exactamente lo que buscaba.

Osea que si leo un fichero y veo estos cuatro bytes en el siguiente orden:

a[0] = 0000 0000 -> 0 0 -> 0 (el byte que está mas cerca del principio)
a[1] = 0000 0010 -> 0 2 -> 2
a[2] = 0110 0110 -> 6 6 -> 102
a[3] = 1011 1001 -> B 9 -> 185 (el byte que está mas cerca del final)

el numero resultante es

(a[0]*256*256*256)+(a[1]*256*256)+(a[2]*256)+a[3]

osea 0*256*256*256 + 2*256*256 + 102*256 + 185=389439 (en decimal)

efectivamente son cuatro bytes en los que está la longitud de bytes que debo leer (datos). Al final de esos datos hay otros cuatro bytes con un CRC que sirve para comprobar la integridad de esos datos.

Agradecido