解除分配多个内存指针的最方便的方法？

Question

我正在寻找大多数 convenient/best/smartest 多内存重新分配的方法。不太确定这是否是最好的解释，但这里有一个例子可以说明我想做什么：

void func()
{
    int* ptr1 = malloc(1);
    if(ptr1 == NULL)
    {
        //...
    }

    int* ptr2 = malloc(1);
    if(ptr2 == NULL)
    {
        //...
        free(ptr1);
    }

    int* ptr3 = malloc(1);
    if(ptr3 == NULL)
    {
        //...
        free(ptr2);
        free(ptr1);
    }

    //code...
}

我唯一想到的是充满标志的数组，如果标志被提升，则必须释放特定的内存。还有其他更方便的方法吗？你可以想象如果需要更多 malloc()-ing，我需要重复多少次 free()。

Answer 1

您可以使用 array of pointers 并记录完成的 malloc 的数量。并使用一个通用的免费功能 free 全部。喜欢，

void func()
{
    char* ptr[10];
    int n = 0, i;

    for(i = 0; i < 10; i++)
        ptr[i] = NULL;

    ptr[n] = malloc(1);
    if(ptr[n] == NULL)
    {
        //...
    }
    n++;

    ptr[n] = malloc(1);
    if(ptr[n] == NULL)
    {
        //...
        custom_free(ptr1, n);
    }
    n++;

    ptr[n] = malloc(1);
    if(ptr[n] == NULL)
    {
        //...
        custom_free(ptr, n);
    }
    n++;
    //code...
}

custom_free() 可以是这样的，

void custom_free(char* ptr[], int n)
{
    int i;

    for(i = 0; i <= n; i++)
        free(ptr[i]);
}

Answer 2

你贴的是一个函数中常见的错误处理和资源释放的做法，你获取了多个资源，如果出现错误，你需要释放之前获取的资源，没有错，只是一个一个做。

void func(void) {
    void *ptr1 = NULL;
    void *ptr2 = NULL;
    void *ptr3 = NULL;

    ptr1 = malloc(SIZE);
    if (!ptr1) goto end;

    ptr2 = malloc(SIZE);
    if (!ptr2) goto end;

    ptr3 = malloc(SIZE);
    if (!ptr3) goto end;

    // do your work with the buffers

end:
    free(ptr1);
    free(ptr2);
    free(ptr3);
}

Answer 3

另一种方法是在一个大块中分配所有需要的内存，并将其中的部分视为 p0,p1,p2:

void worker(void)
{
#define N_ELEM 123
int *work_mem;
int *p0,*p1,*p2;

work_mem = malloc ( 3* N_ELEM * sizeof *work_mem);
if (!work_mem) { OMG(); return; }

p0 = work_mem, p1= work_mem + N_ELEM, p2 = work_mem + 2 * N_ELEM;

        /* do useful stuff here with work_mem
        ** , possibly via p0,p1,p2
         */

free(work_mem);
}

解除分配多个内存指针的最方便的方法？

Most convenient way to deallocate multiple memory pointers?

c

memory-leaks

memory-management

heap-memory

dynamic-memory-allocation