我应该在析构函数中释放所有成员（动态分配）吗？

Question

#include <iostream>
#include <vector>
using namespace std;
#define l(x) cout << (#x) << " : " << x << endl;
#define forf(x, fromY, Step, toZ) for(double x = fromY; x <= toZ; x+=Step)

class Particle {
public:
    Particle() {
        totalYield = winRate = 0;
    }
    ~Particle() {
        //cout << " Particle destructor were called";
        args.~vector();
    }
    Particle(double* inputArgs, int nSize) 
    :args(nSize)
    {
        for (int i = 0; i < nSize; i++) {
            args[i] = inputArgs[i];
        }
        totalYield = winRate = 0;
    }
    double GetAt(int i = 0) {
        return args[i];
    }

protected:
    double winRate, totalYield;
    unsigned int winCount, totalCount;
    vector<double> args;
};

您好，我从教科书中了解到，在使用动态分配后我必须释放所有内存。

根据我的学习，析构函数将其成员的析构函数称为默认值（没有任何命令）

1. 我的第一个问题是，如果我在类中使用动态分配的数组，我应该在析构函数中释放它们吗？目前还不清楚，因为解构器自然会将其成员的析构函数称为默认值。这个执行是否释放了动态分配的内存？
2. 我的第二个问题是：我应该在类的析构函数中调用成员向量的析构函数吗？ （参见args .~vector（）; //我应该这样做吗？这是对的吗？）

Answer 1

如果我在类中使用动态分配的数组，我应该在解构器中释放它们吗？

如果你的类分配内存，那么你的类应该释放它。如果动态数组类分配内存，那么该动态数组类应该释放内存。

解构主义者自然称其成员的解构主义为默认。这个执行是否释放了动态分配的内存？

让我们看看std::vector的析构函数的引用是什么：

破坏容器。调用元素的析构函数并释放已使用的存储。

事实证明，是的，记忆确实被释放了。这是一个容器的好设计。

---

我应该在类的解构器中调用成员向量的解构函数吗？ （参见args .~vector（）; //我应该这样做吗？这是对的吗？）

不，你不应该，这是不对的。因为 - 如你所说 - “解构者将其成员的解构者称为默认”。为了澄清，在执行析构函数体之后，成员总是被销毁。如果你也在析构函数体内调用一个成员的析构函数，那么析构函数将被调用两次，这是非常糟糕的。

隐式析构函数是正确的，对于您的类来说已经足够了。您无需明确定义它。

几乎不需要显式调用析构函数。当超级对象被销毁时，会自动调用基础子对象和成员的析构函数。销毁数组时会自动调用数组元素的析构函数。当自动对象超出范围时，将自动调用自动对象的析构函数。在delete表达式上自动调用动态对象的析构函数。在main函数返回之后发生的静态破坏期间会自动调用静态对象的析构函数。在这些情况中都不需要显式调用析构函数。

唯一需要显式调用析构函数的情况是在对象的存储被重用于其他对象的情况下 - 这是一种您不需要学习的高级技术。