在具有多个返回点的函数中清理的正确方法

Question

我有一个递归搜索算法，我想在每次调用后清理我的指针。但是，我在这么多地方返回，在每个之前都放一个delete 或free 似乎很草率。

有没有更好的方法？我在函数返回时释放它们是否意味着我应该将它们分配在堆栈而不是堆中？

注意这是一个并行搜索（代码中没有显示），但是调用者永远不会在它的孩子之前返回。使用堆栈是否有任何额外的陷阱？

示例代码（这里不用担心算法）：

//create a new struct state (using new), initialize and return (C style)
new_state()

free_list(state* node)//free a list

double minimax(state* node, state* bestState) {

    if (base_case) {
        return;
    }

    state* gb = new_state(); //single node
    state* children = new_state(); //head of list

    generate_children(children); //fill list

    state* current = children; //traverse node

    //recurse on child
    double result = -minimax(current, gb);

    if (case1) {
        free(gb);
        free_list(children);
        return;
    }
    if (case2)  {
        //do stuff
    }

    while(current != NULL){
        result = -minimax(current, gb);
        if (case1) {
            free(gb);
            free_list(children);
            return;
        }
        if (case2)  {
            //do stuff
        }
        current = current->next;
    }
    free(gb);
    gb = NULL;

    //More stuff (with children but not gb)
    free_list(children);
    return;
}

Answer 1

但是，我在这么多地方返回，在每个地方都放一个 delete 或 free 似乎很草率。

是的。

有没有更好的办法？

是的。智能指针是一种更好的方法。但是，如果您不想放弃正在做的事情，并在继续之前学习如何使用智能指针（第一次可能很难），请继续往下阅读。

我在函数返回时释放它们是否意味着我应该将它们分配到堆栈而不是堆中？

是的，你可以这样做。它也会表现得更好。但是，如果您打算分配大量内存，它将不起作用。

注意这是一个并行搜索（代码中没有显示），但是调用者永远不会在它的孩子之前返回。使用堆栈是否有任何额外的陷阱？

陷阱是一样的。使用并行代码，您必须小心。

有很多方法可以避免这个问题。已经提到了智能指针和堆栈分配。

另一种方法是只有一个出口点。这有时会变得笨拙，因为例如，这意味着您必须在循环中断之前在循环中设置一个标志，以便知道它是成功终止还是由于错误而终止。

另一种方法是在函数 A 中分配指针，调用函数 B 来完成实际工作，（将分配的指针传递给它），然后一旦函数 B 返回到函数 A，释放指针。

Answer 2

这是一个小样本的 RAII：

首先，我们有一个 struct 来简单地存储您的物品。

struct FreeAll
{
    state* gb;
    state* children;
    FreeAll(state* g, state* c) : gb(g), children(c) {}
    ~FreeAll() { free(gb); free(children); }
};

请注意，在销毁时，两个项目都会调用free()。怎么用？

double minimax(state* node, state* bestState) 
{
    if (base_case) {
        return;
    }

    state* gb = new_state(); //single node
    state* children = new_state(); //head of list

    // Initialize our small RAII object with the above 
    // pointers   
    FreeAll fa(gb, children);

    generate_children(children); //fill list
    state* current = children; //traverse node
    //recurse on child
    double result = -minimax(current, gb);

    if (case1) {
        return;
    }
    if (case2)  {
        //do stuff
    }

    while(current != NULL){
        result = -minimax(current, gb);
        if (case1) {
            return;
        }
        if (case2)  {
            //do stuff
        }
        current = current->next;
    }
    //More stuff (with children but not gb
    return;
}

局部变量fa 是FreeAll 类型。当此本地超出范围时，将调用fa 的析构函数，该析构函数在存储在struct 中的两个指针上调用free。还要注意在返回点没有任何代码来释放内存。这将由fa 在超出范围时完成。

请注意，这是一个简单的示例，没有提到的其他方法那么复杂，但它为您提供了 RAII 范例的基本要点。

Answer 3

ScopeGuard 为您完成这项工作。

https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Scope_Guard

void your_function()
{
     Scope_guard const final_action = []{
            free(gb);
            free_list(children);};
     // your code here
 };