Question

我正在寻找最方便/最好/最聪明的多内存释放方式。不太确定这是否是最好的解释，但这里有一个例子，将显示我想做的事情：

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...
}

只有我想到的是数组填充了标志，如果标志被提出，则必须释放特定的内存。有没有其他更方便的方法来做到这一点？您可以想象，如果需要更多free()，我需要重复malloc()次。

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);
}

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

3 个答案: