c - 在 C 中进行清理的另一种方法？

Question

考虑这个程序：

int main(void)
{
    int* i = malloc(sizeof(int));
    int* j = malloc(sizeof(int));
}

然而，这是一种幼稚的方法，因为malloc可能会失败并且指针不是free'd。

所以你可以这样做：

int main(void)
{
    int* i; 
    int* j;

    if ((i = malloc(sizeof(int)) < 0)
    {
        return -1;
    }
    if ((j = malloc(sizeof(int)) < 0)
    {
        free(i);
        return -1;
    }

    free(i);
    free(j);
}

但是我认为这很容易出错。考虑必须分配 20 个指针，在最后一个malloc错误情况下，您必须分配free19 个变量，然后return -1.

我也知道atexit，这可以帮助我这样写：

int* i; 
int* j;

void del_i(void)
{
    free(i);
}

void del_j(void)
{
    free(j);
}

int main(void)
{
    if ((i = malloc(sizeof(int)) < 0)
    {
        return -1;
    }
    else
    {
        atexit(del_i);
    }

    if ((j = malloc(sizeof(int)) < 0)
    {
        return -1;
    }
    else
    {
        atexit(del_j);
    }
}

哪个更好，但我不喜欢必须将所有指针声明为全局指针。有没有办法将这两种方法结合起来，基本上：

1. 具有指针的析构函数，可以直接执行或与atexit.
2. 具有指向函数的本地指针。

Answer 1

freeonNULL被定义为安全无操作。所以一个非跳跃的变化可能是：

int *i = malloc(sizeof(int)); 
int *j = malloc(sizeof(int));

if(i && j)
{
    // do some work
}

free(i);
free(j);

Answer 2

首先，这不会检测到malloc故障：

if ((i = malloc(sizeof(int)) < 0)
{
    return -1;
}

malloc失败时返回NULL，而不是负数。

其次，atexit有利于清理静态和全局对象。将局部对象设为全局对象只是为了在内部使用它们并不是一个好主意atexit。

更好的方法是struct为所有需要在全有或全无单元中分配的相关指针创建一个，定义一个一次性释放它们的函数，并编写一个函数，逐个分配它们并检查每个指针分配：

typedef struct AllOrNothing {
    double *dPtr;
    int *iPtr;
    float *fPtr;
    size_t n;
} AllOrNothing;

void freeAllOrNothing(AllOrNothing *ptr) {
    free(ptr->dPtr);
    free(ptr->iPtr);
    free(ptr->fPtr);
    free(ptr);
}

int allocateAllOrNothing(size_t n, AllOrNothing **res) {
    *res = malloc(sizeof(AllOrNothing));
    if (*res == NULL) {
        return -1;
    }
    // Freeing NULL is allowed by the standard.
    // Set all pointers to NULL upfront, so we can free them
    // regardless of the stage at which the allocation fails
    (*res)->dPtr = NULL;
    (*res)->iPtr = NULL;
    (*res)->fPtr = NULL;
    (*res)->n = n;
    (*res)->dPtr = malloc(n*sizeof(double));
    if ((*res)->dPtr == NULL) {
        free(*res);
        *res = NULL;
        return -1;
    }
    (*res)->fPtr = malloc(n*sizeof(float));
    if ((*res)->fPtr == NULL) {
        free(*res);
        *res = NULL;
        return -1;
    }
    (*res)->iPtr = malloc(n*sizeof(int));
    if ((*res)->iPtr == NULL) {
        free(*res);
        *res = NULL;
        return -1;
    }
    return 0;
}

Answer 3

int main(void)
{
int* i = NULL; // Init with NULL otherwise free on none NULL possible
int* j = NULLL;

if (!(i = malloc(sizeof(int)))
{
    goto exit;
}
if (!(j = malloc(sizeof(int)))
{
    goto exit;
}
...
exit:
    free(i);
    free(j);
    ...
    return err;
}

这是您可以使用 goto 语句解决的问题。

Answer 4

int main(void)
{
    int* i = NULL; 
    int* j = NULL;
    bool success = false;

    do {
        i = malloc(sizeof(int));
        if (NULL == i) break;

        j = malloc(sizeof(int));
        if (NULL == j) break;

        success = true;
    } while (0);

    if (!success)
    {
        printf("Something failed!");
    }
    else
    {
        printf("All succeeded!");
        // Do more work
    }

    free(i);
    free(j);
    return (success? 0 : 1);
}

Answer 5

避免多个出口点。避免交错分配和错误处理。遵循干净的操作顺序：

1. 声明、分配和初始化资源..
2. 如果一切顺利，做任务。
3. 清理。
4. 返回状态。

---

 // Do all allocations first, test their `NULL`-ness, then free them all.
 int main(void) {
    // Allocate resources   
    // declare and allocate in one step
    int* i    = malloc(sizeof *i);
    double* j = malloc(sizeof *j);

    // Test for acceptability
    bool ok = i && j;

    // Perform the main body of code
    if (ok) {
      ; // do normal process in the code;
    }

    // free resources
    free(i);
    free(j);

    // return status
    return ok ? 0 : -1;
}

Answer 6

    int *i=NULL,*j=NULL;

    if(!(i=malloc(sizeof(int))))
            goto EXIT;
    if(!(j=malloc(sizeof(int))))
            goto EXIT;
    /* do some work */
    return 0;
    EXIT:
            free(i);
            free(j);
            exit(EXIT_FAILURE);

尽管 goto 被认为是一种不好的编程习惯，但在这里我们可以使用它来轻松简单地完成任务