Thread: Dynamic mem allocation, how to get it right?

I have tried to dynamically set the size of an array depending on a input file´s size.
What I have done is, first using fseek() and ftell() to fetch the start and end of the data in the file.
I then subrtact start from end and store that in the variable size.

What I would like to know now is if using size in an array declaration actually works as I expect it to or if I have to use malloc().

This is what I tried first:

Code:

UInt8 dataArray[size];

// where size is the previously unknown size of the file or data

I wasn´t actually sure if this would work under all conditions, so I tried malloc like this:

Code:

UInt8 *dataArray = malloc(size);
void *dataPt = NULL;

dataPt = &dataArray;

I´m trying to use the void pointer to access different places in dataArray by increment it´s value here.

Code:

	for(dataCounter = 0; dataCounter < 120; dataCounter++) {
			data[i].data[dataCounter] = *dataPt;
			dataPt++;
		}

This gives me this warning: assignment makes integer from pointer without a cast

If I try to cast it I´m informed that I should not attempt to cast a void pointer? I thought that was what they where good for.











EDIT: This was weird, I just tried to compile this again and got a new error and warning like this:

warning: dereferencing ‘void *’ pointer
error: void value not ignored as it ought to be

If what you want is an int*, use and int*.

Code:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
	int size=atoi(argv[1]), dataray[size], *ptr=dataray, i;
	for (i=0; i<size; i++) {
		*ptr=i;
		printf("%d\n",dataray[i]);
		ptr++;
	}
	
	return 0;
}

Compiles with no errors.
./a.out 4
0
1
2
3

Originally Posted by MK27

Compiles with no errors.

Though there might be an error if one were compiling with respect to the 1990 edition of the C standard since a variable length array is used, but it would be fine with C99. Also, atoi() is found in <stdlib.h>, which was not included. There is also a potential problem in that argv[1] would be a null pointer if the user runs the program without any command line arguments.

The one with malloc is almost exactly the same (now stdlib.h is definitely needed):

Code:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
	int size=atoi(argv[1]), *dataray=malloc(size*sizeof(int)), *ptr=dataray, i;
	for (i=0; i<size; i++) {
		*ptr=i;
		printf("%d\n",dataray[i]);
		ptr++;
	}
	free(dataray);
	
	return 0;
}

Remember, if you don't give an argument it will seg fault.

Originally Posted by Subsonics

If it´s ok to use a variable with unknown value at compile time to declare an array that´s good news. It worked for me as well, but I just wasn´t sure.

As I noted in post #5, that is the variable length array feature introduced in the 1999 edition of the C Standard. There are limitations, e.g., the array cannot be expanded, unlike what you can do with say, realloc().

For a somewhat more robust version of MK27's malloc() example:

Code:

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>

int main(int argc, char *argv[]) {
    size_t size;
    int *data;
    size_t i;

    if (argc < 2) {
        puts("Please provide a non-negative integer command line argument.");
        return 0;
    }

    size = atol(argv[1]);
    data = malloc(size * sizeof(*data));
    if (data == NULL) {
        fprintf(stderr, "Error: unable to allocate memory.\n");
        return EXIT_FAILURE;
    }

    for (i = 0; i < size; ++i) {
        data[i] = i;
        printf("%d\n", data[i]);
    }

    free(data);

    return 0;
}

Code:

UInt8* dataArray = malloc(size);
void* dataPt = NULL;
dataPt = &dataArray;

This now stores the address of the pointer dataArray inside dataPt, so essentially it stores an Uint8**, masqueraded as void*.

Code:

	for(dataCounter = 0; dataCounter < 120; dataCounter++) {
			data[i].data[dataCounter] = *dataPt;
			dataPt++;
		}

This gives me this warning: assignment makes integer from pointer without a cast

EDIT: This was weird, I just tried to compile this again and got a new error and warning like this:

warning: dereferencing ‘void *’ pointer
error: void value not ignored as it ought to be

I don't know what exactly data & co are, but I do spot one problem.
dataPt++;
void* is a pointer to an unknown value, so it illegal to increment as well as dereference it. The compiler does not know the size of what it points to, so it cannot know how many bytes to advance with ++.
If you dereference a void* pointer, theoretically you would get void. But void is an illegal type that cannot be assigned to or from, so that compiler complains yet again.

If I try to cast it I´m informed that I should not attempt to cast a void pointer? I thought that was what they where good for.

They are. Sort of.
Just remember that there's no guarantee what you cast to is what it actually is. You have to be careful to make sure it's right.

so essentially it stores an int**,

actually UInt8**


and there is no need to cast void pointer in C while assigning it to another pointer

Originally Posted by vart

actually UInt8**

Right. My mistake O_O

and there is no need to cast void pointer in C while assigning it to another pointer

But technically, you still get the same effect as when you cast it, so the result is the same.

So would using += 1 work instead of ++ in this example?

No, the pointer arithmetic does not work at all on the void pointer, because the size of the pointed object is unknown

back to declaring the pointer UInt8

pointer to UInt8 and pointer to pointer to UInt8 are different things

I have decided to ignore that for now however

Ignoring warnings that you do not understand is the easiest way to write a code that does absulutely different things from your intentions

Is the problem that I have allocated memory for what I´m pointing to?

no

Does this mean that dereferencing a void pointer always raise a compiler warning?

you cannot dereference void pointer - so it will raise error not warning