Thread: Read Bytes From File Into Integer

I'm sure this question has been asked here before, but I've searched and haven't found the answer I'm looking for.

In C, NOT C++ (using stdio), suppose I write a value to a file:

Code:

FILE *fp = fopen ("data.txt", "wb");
int myValue = 1500;

fwrite (&myValue, 2, 1, fp);

Now, how do I read this integer value from the file, since it's stored across two bytes, and get 1500 as an integer again?

Well when I use fread,

Code:

int byteVal;

fread (&byteVal, 2, 1, fp)

It doesn't work and I get a really big number (4195804 -apparently an address). It even does this when I try to input four bytes.

Here's my full program:

Code:

#include <stdio.h>

int main ()
{
    FILE *fp;
	int number = 1500;
    int inpNumber;
	
	fp = fopen ("test.txt", "wb");
	fwrite (&number, 2, 1, fp);
	fclose (fp);

	fp = fopen ("test.txt", "rb");
	fread (&inpNumber, 2, 1, fp);
	fclose (fp);
    
    printf ("%i", inpNumber);

    return 0;
}

Do NOT hard-code sizes, use the sizeof operator:

Code:

FILE *fp = fopen ("data.txt", "wb");
int myValue = 1500;
fwrite(&myValue, sizeof(myValue), 1, fp);

Code:

FILE *fp = fopen ("data.txt", "rb");
int myValue;
fread(&myValue, sizeof(myValue), 1, fp);

Yes, I created a file of my own format, and I have different [integer] data items that span two or more bytes. I just need to know how to read one of these variables, whether it is two, three, or four bytes in length and store it in an integer so my program can work with it. Therefore, sizeof() wil not work.

Originally Posted by ChadJohnson

Yes, I created a file of my own format, and I have different [integer] data items that span two or more bytes. I just need to know how to read one of these variables, whether it is two, three, or four bytes in length and store it in an integer so my program can work with it. Therefore, sizeof() wil not work.

Well, then viaxd's method should do the trick.

You can also use unions to access individual bytes of an integer:

Code:

#include <stdio.h>
                                                                                
union MY_INT {
        int val;
        char arr[4];
};
                                                                                
int main(void) {
        union MY_INT i;
        i.val = 1500;
        printf("%d, %d, %d, %d: %d\n", i.arr[0], i.arr[1], i.arr[2], i.arr[3]);
        return 0;
}

Another way to see what is actually in the file is to cast the address of an int to the address of a char.

Now, you can't just read two bytes into an int variable and expect to get something meaningful unless you know what's in the other bytes.

Also, the order in which the bytes are stored is processor-dependent, since compilers usually store int data in the "natural mode" of the processor (big-endian vs little-endian).

Try this on your machine to see if you get any insight into why you could get the results that you saw. I have left the fwrite() the way that you had it, and read the bytes back in with a corresponting fread().

In any program that you intend to use or release for others to use, you should always have lots of error checking (I have left it as an exercise).

On Intel machines (Windows as well as Linux), the file data.txt consisted of exactly two bytes: 0xdc and 0x05.

Code:

#include <stdio.h>

int main()
{
  FILE *fp;
  int i;
  int myValue;
  int inValue;
  unsigned char *ChPoint;

  myValue = 1500;
  ChPoint = (unsigned char *)&myValue;

  printf("sizeof(myValue) = %d\n", sizeof(myValue));

  printf("myValue = %d, (%08x hex)\n", myValue, myValue);

  for (i = 0; i < sizeof(myValue); i++) {
    printf("byte %d = %02X\n", i, *(ChPoint + i));
  }


  /* write the bytes */
  fp = fopen("data.txt", "wb"); /* should do error checking */
  fwrite (&myValue, 2, 1, fp);  /* should do error checking */
  fclose(fp);

  /* read two bytes into an integer */
  inValue = 0;
  printf("Before reading: inValue = %d (%08x hex)\n", inValue, inValue);
  fp = fopen("data.txt", "rb"); /* should do error checking */
  fread(&inValue, 2, 1, fp);    /* should do error checking */
  fclose(fp);

  printf("After  reading: inValue = %d (%08x hex)\n\n", inValue, inValue);

  /* read two bytes into an integer */
  inValue = -1;
  printf("Before reading: inValue = %d (%08x hex)\n", inValue, inValue);
  fp = fopen("data.txt", "rb"); /* should do error checking */
  fread(&inValue, 2, 1, fp);    /* should do error checking */
  fclose(fp);

  printf("After  reading: inValue = %d (%08x hex)\n", inValue, inValue);

  return 0;
}

Regards,

Dave

wait a sec...how did setting inValue to 0 change the result?

Originally Posted by ChadJohnson

wait a sec...how did setting inValue to 0 change the result?

The function fread() puts two bytes into the 4-byte variable. The upper two bytes were "something else", therefore giving different values. Look at the for(){} loop near the beginning of the program. Put copies of this loop before and after the fread() statements.

Two observations:
1. It makes sense once you get it.
2. It's easier to do than it is to talk about it.

This example also shows why you can't prove that a program works just by testing. In my case, the Borland compiler gave the "right" answer even when I didn't make any assignment to inValue (but gcc didn't). Bottom line: when you are reading (binary) bytes, make sure you know where they are going, and what else is there.

Dave

Originally Posted by ChadJohnson

What if I just did a bit-shift and shifted everything 2 bits - would that work? (sorry this is my first time really working with bits)

I'm not sure what you mean.

The function fread() stores a certain number of bytes into memory locations starting at the (byte) address that you give it.

If you want to read one byte at a time and use shift-store into an int, you could consider:

1. Read the first byte into a variable of type unsigned char; suppose its name is byte1.

2. Read the second byte into a variable of type unsigned char; suppose its name is byte2.

Now calculate and store the integer value:

Code:

  int_value = byte1 + 256*byte2;

or, if you prefer logic:

Code:

  int_value = byte1 | (byte2 << 8);

where I have assumed that char data are one byte, and a byte is eight bits. (I have also assumed little-endianness of int storage.)

The assignment statement takes care of all of the bits, whereas fread() just stores the bits in the bytes it gets.

Dave