Thread: malloc() vs buffer[]?

I wanted to know the difference between using malloc() to allocate data to a pointer and creating an array[].
I'm writing a program that gets data from the internet and stores a part of it. It reads a packet with the length of the data that is coming next, then it malloc()'s space for it and gets it. It happens that, somewhere I may need to do something like storageArea = &packet[x]. This means I can't free(packet) anymore. Would it be better if instead of using malloc() and not freeing the pointer, I created a buffer and maybe afford losing some memory?

it really depends on what you're doing with the data afterwards. If you'll need the information later, you'll want to malloc it so that it will stick around after local variables go out of scope. Also, malloc is useful when you don't know how much memory you'll need at compile-time.

It happens that, somewhere I may need to do something like storageArea = &packet[x]. This means I can't free(packet) anymore.

why not? I think you can. Am I missing something here? You'll have to free it eventually.

Packet is the pointer that was set using malloc(), and storageArea is another pointer, where the data will be stored. If I do "storageArea = &packet[x]", "free(packet)" and then do something with storageArea the program will segfault, because I freed the whole packet memory, and storageArea now points the area freed.
the packet pointer is passed as argument to the function that will handle it.

Yep, but would it be more efficient than using a buffer? Estimate a length and memcpy the contents of the packet to the storage area and free(packet)?

Because it needs to be processed first... A part of it will go to one storage area, then another part will go to another and so on. Then I may need to use storageArea = &packet[x] storageArea2 = &packet[y] storageArea3 = packet[z] and so on. The example I gave above was just an example of what I need to do with the data... By now the program works without having to free the pointer since I'm going to use it later on, but I was wondering if it wasn't better to copy stuff and freeing it, instead of pointing to it, in order to avoid memory leaks.

This:

Code:

struct example
{
unsigned char *storageArea;
unsigned char *storageArea2;
unsigned char storageArea3;
};

unsigned char *packet = malloc(length);
getpacketfromnet(packet);
storageArea = &packet[3];
storageArea2 = &packet[7];
storageArea3 = packet[22];

or this:

Code:

struct example
{
unsigned char storageArea[300]; //300 is an expected length
unsigned char storageArea2[200]; //200 is an expected length
unsigned char storageArea3;
};

unsigned char *packet = malloc(length);
getpacketfromnet(packet);
strcpy(storageArea, &packet[3]);
strcpy(storageArea2, &packet[7]);
storageArea3 = packet[22];
free(packet);

is safer / best?

Assuming they are NULL-terminated strings. If you didn't get what I meant, use memcpy with a a random size then, I didn't want to come up with another variable. This is an _example_ code, it doesn't have to be perfect, it's just to show you the problem. I would understand if you said that if I was asking wether to use memcpy or strcpy.
I didn't get what you said about the first version

I'm just asking if it's better to copy data and free the pointer or if it's ok to point to it without freeing the pointer. Feel free to ignore the code if you think it contain errors, as long as you get the general idea.