如何释放结构内部的指针？

Question

我对结构很陌生，所以请耐心等待。我编写了一个名为 gnt 的结构，其中包含一个整数指针、一个整数和一个布尔值：

struct gnt
{
    unsigned int* num;
    unsigned int size;
    bool negative;
};

因为我将任意长度的 int 数组分配给各种 gnt 变量（即 k.num = new int*[j] ）（对于某些值j），我需要以某种方式释放它们。我不知道该怎么做。我是否只需使用 delete[] k.num; （其中 k 是 gnt）？我需要担心结构本身吗？

另外，作为一个附带问题，我编写了一个递归函数来乘以列表中的项目：

char* chain_multi(char** list, unsigned int start, unsigned int end)
{
    /***************************************************************
    This function recursively multiply every items in a list then
    return the product.
    ***************************************************************/
    unsigned int size = start - end + 1;
    if(size == 1)
        return copy_char(list[end]);
    if(size == 2)
        return multiplication(list[start], list[end]);

    int rs = start - size / 2;
    char* right = chain_multi(list, rs, end);
    char* left = chain_multi(list, start, rs + 1);
    char* product = multiplication(left, right);
    delete[] left;
    delete[] right;
    return product;
}

这与不使用递归相比是否有任何优势？我测试了各种大小的列表（10 - 10000 个条目之间），似乎在时间上没有任何优势......不过，递归代码比其对应代码短。

感谢您的任何意见。

Answer 1

由于您使用的是 C++，因此您可以在结构中放置一个析构函数来自动为您执行此操作。还有其他方法，但这是最实用的：

struct gnt
{
    unsigned int* num;
    unsigned int size;
    bool negative;
    ~gnt() {delete [] num; }
};

我还建议有一个构造函数来确保 num 在初始化之前具有 null，因此析构函数将在此之前安全地工作：

struct gnt
{
    unsigned int* num;
    unsigned int size;
    bool negative;
    gnt() : num(NULL) {}
    ~gnt() {delete [] num; }
};

在分配实例时具有安全的行为或者在创建时初始化，需要复制构造函数和赋值运算符。他们应该复制所有非动态成员的值，并创建具有相同大小和内容的 num 副本。在这种情况下，还建议初始化构造函数中的所有成员，因为 size 也应该始终具有有效的内容才能发挥作用。如果您现在不想让事情变得太复杂，只需将它们设为私有即可，如果您尝试执行（不支持的）对象分配或复制，这将导致编译器发出警告：

struct gnt
{
    unsigned int* num;
    unsigned int size;
    bool negative;
    gnt() : num(NULL) {}
    ~gnt() {delete [] num; }
    private: gnt(const gnt&); gnt &operator = (gnt &);
};

正如其他人所建议的，一种替代方法是使用 std： :向量而不是原始指针。这样，您就不需要担心释放：

struct gnt
{
    std::vector<unsigned int> num;
    unsigned int size;
    bool negative;
};

关于“我是否必须担心结构本身？”的问题，这取决于您如何创建其实例。如果是 new 操作员，是的。如果不是，当它们像任何其他变量一样超出范围时，它们将被释放。

最后，关于递归，IMO 很少选择与代码效率有关的选择。仅当代码变得更简单/更清晰并且不存在不利影响（如堆栈溢出）的危险时，才应使用递归。如果不是这种情况，我总是会选择迭代版本。

Answer 2

遵守规则：
您应该将与从 new[] 收到的相同地址传递给 delete[]。
如果您只在 freestore 上分配了一个成员，那么您只需要取消分配该成员。

您使用 new [] 分配了成员 k.num，因此您应该仅为它调用 delete []。

另外，您可以使用 std::vector 而不用自己进行内存管理（除非这是一些限制您这样做的蹩脚分配）

---

对于 Standerdese 粉丝：
标准 C++03 § 3.7.4.2-3：

如果释放函数因抛出异常而终止，则行为未定义。提供给释放函数的第一个参数的值可以是空指针值；如果是这样，并且如果释放函数是标准库中提供的函数，则调用无效。否则，提供的值
标准库中的运算符 delete(void*) 应是先前调用运算符 new(std::size_t) 或 返回的值之一标准库中的operator new(std::size_t, const std::nothrot_-t&)，以及提供给标准库中的operatordelete[](void*)的值应是其中之一先前调用 operator new[](std::size_t) 或
标准库中的operator new[](std::size_t, const std::nothro_t&)。

Answer 3

递归的通常优点是简单和清晰（并且可能是解决问题的不同方法），通常不是速度。事实上，过去的情况恰恰相反：递归实现往往比迭代实现慢得多。现代硬件已经消除或大大减少了这种速度差异，但递归实现比迭代实现更快仍然是相当不寻常的。

Answer 4

free 适用于任何指针，无论它是否是结构成员。如果您正在编写 C 代码，也许使用 malloc() 和 free() 会更好。

是否递归取决于上下文。一般来说递归是可以的。由于一些函数调用和参数传递开销，递归稍微慢一些。递归的问题在于，如果您的递归级别非常深（可能有 1000 个嵌套函数调用），您最终可能会填满堆栈。这会导致程序崩溃。