Malloc和释放多个指针

Question

I'm working with a c++ program that uses multiple buffers and I'm getting a seg fault a few minutes into running the program. I'm unsure of the correct way to go about it. The code that I think is giving me the fault is currently as such:

int *myBuf1, *myBuf2;
myBuf1 = (int*)malloc(sizeof(int) * maxPacketSize);
myBuf2 = myBuf1;
// do work

if(myBuf1) {
    free(myBuf1);
}
myBuf1 = NULL;
myBuf2 = NULL;

My first question is: with the assignment 'myBuf2 = myBuf1', does myBuf2 allocate a different block of memory with sizeof(int) * maxPacketSize, or is it just a pointer to the same block of memory allocated by myBuf1?

Secondly, should I be freeing myBuf2 as well as myBuf1, then setting both to NULL? Above I'm only freeing myBuf1. OR, is it best to do:

myBuf1 = (int*)malloc(sizeof(int) * maxPacketSize);
myBuf2 = (int*)malloc(sizeof(int) * maxPacketSize);

then free both?

Answer 1

Q: with the assignment 'myBuf2 = myBuf1', does myBuf2 allocate a different block of memory?

A: No

Q: Secondly, should I be freeing myBuf2 as well as myBuf1?

A: No. One malloc (), one free().

Q: [Should I] then set both to NULL?

A: Yes, I would strongly encourage setting ALL pointers to NULL.

Answer 2

First, you haven't declared two pointers.

int *myBuf1, myBuf2;

This declares a myBuf1 as an int* and myBuf2 as an int (not a pointer). You need to write:

int *myBuf1, *mBuf2;

Second, no, assigning one pointer to another does not copy the memory, it just creates two pointers that point to the same thing.

You only need to free one. Also, there is no need to set to NULL afterwards, although in some cases it can help in avoiding some tricky bugs.

Answer 3

Assigning myBuf1 to myBuf2 simply makes myBuf2 point to the same location as myBuf1 . Consequently doing this:

myBuf1 = (int*)malloc(sizeof(int) * maxPacketSize);
myBuf2 = (int*)malloc(sizeof(int) * maxPacketSize);

and then myBuf1 = myBuf2; will just allocate memory for myBuf2 for no reason.

Conclusion: freeing any one of them will be sufficient.

And BTW your myBuf2 is just an int , not an int* , which is probably the cause for your segfault.

Answer 4

Change

int *myBuf1, myBuf2;

to

int *myBuf1, *myBuf2;

If you want to have to distinct blocks of memory, you will need two separate allocations:

myBuf1 = (int*)malloc(sizeof(int) * maxPacketSize);
myBuf2 = (int*)malloc(sizeof(int) * maxPacketSize);

Consider using calloc .

Answer 5

After the line:

myBuf1 = (int*)malloc(sizeof(int) * maxPacketSize);

you must check that malloc( ) did not return a NULL pointer, indicating failure. eg:

myBuf1 = (int*)malloc(sizeof(int) * maxPacketSize);
if (myBuf1 == NULL) {
  printf ("malloc ( ) failed!\n");
  exit(1);
}

Answer 6

Q: [Should I] then setting both to NULL?

A: Yes, I would strongly encourage setting ALL pointers to NULL.

If you are inside a block, there no use of setting back pointers to null. For the compiler, it's doing nothing and for the reader it's more confusing.

In C++, it's a good practice to use blocks to limit the scope of identifiers, especially pointers.