Why do the values in the array change after exiting the loop? - c

Question

After exiting the while loop for some reason the values in the array change but I'm not why. Inside the loop the values are correct and they store inside the array (a) normally. This is in c!
int * readFile()
{
char file_name[50];
printf("Enter the name of the file to open:\n");
scanf("%s",file_name);
FILE *fp;
fp = fopen(file_name,"r");
if(fp == NULL )
{
printf("Sorry but the File you entered cannot be opened\n");
int *b;
b[0] = -1;
return b;
}
int *a;
int j=0;
long int value=0;
while (fscanf(fp,"%d",&value)!=EOF) {
if((a =malloc(sizeof(long int))) == NULL)
printf("not enough memory\n");
a[j]=value;
j++;
}
printf("%d %d %d\n",a[0],a[1],a[2]);
int i=0;
for(i=0; i<j;i++)
{
printf("array[%d] = %d\n",i,a[i]);
}
fclose(fp);
return a;
}
Any help would be greatly appreciated!

Answer 1

When you do if((a =malloc(sizeof(long int))) == NULL) you are only allocating enough memory for a single long int ( 32 bits in size), but you need to allocate memory for each int that you plan to store. Because malloc allocates a single block of memory, you need to know how many ints you plan to store before hand. If you don't mind the overhead, you can do a preliminary run through the file being read and count the number of ints you will read (basically your j variable) , then you can do
a =malloc( intCounter * sizeof(long int))) == NULL , where intCounter would be the total number of integers in the file (j).
Another option would be to use a linked list,(which is close to what your trying to do) where you can allocate memory for each int on the fly, but you will need to store pointer information to the next node in the array.
The malloc call in the while loop overwrites the data that was stored in the single allocation of an Int. For example if you read 1 2 3 from the text file it would store 1 in the a, malloc different memory adress to a, store 2, malloc yet another memory address and store 3. Resulting in 0 , 0 , 3 to be printed.

Answer 2

You have used a mix of int and long int throughout your code. You need to settle on a consistent type; for my answer I've gone with int. (You could easily go through and change all occurrences of int to long though, so long as you also change the fscanf format string to %ld).
Currently you allocate a new block of one long int each time around the loop. As well as leaking memory from previous loop iterations, you access out of bounds of this. Also, when malloc fails you print a message and keep going!
Instead you need to allocate a single block which will hold several integers. One way to do this is by using the realloc function to make the existing allocation bigger.
Also, when checking the return value of fscanf, you should check for == 1 here. It will return 0 if they typed in some letters but did not trigger EOF condition, and so your program will go on forever.
Here is how that loop could look like:
int *a = NULL;
size_t j = 0;
while ( fscanf(fp,"%d",&value) == 1 )
{
int *ptr = realloc( a, (j+1) * sizeof *a );
if ( !ptr )
{
printf("not enough memory\n");
break;
}
a = ptr;
a[j]=value;
j++;
}
By using a separate variable ptr for the new allocation, we can recover from out-of-memory condition (the program can continue working with the number of ints that were input so far).
If you intend to handle out-of-memory by immediately exiting the program (e.g. by calling exit(EXIT_FAILURE); instead of break; then you could shorten your code a bit by using a = realloc( a, etc. instead of ptr.
The earlier code int *b; b[0] = -1; has a problem: b doesn't point anywhere but you write through it.
This function has a design problem in that the caller has no way of knowing what j was. One solution to this would be to always put -1 on the end of the input (this idea is called "sentinel value" - and remember to allocate space for it); another option would be to have an "out" parameter to the function.