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

你好，我从课本中学到，使用动态分配后，我必须释放所有内存。

据我了解，析构函数将其默认为成员的析构函数（无需任何命令）

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

Answer 1

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

如果您的类分配了内存，则您的类应取消分配它。如果动态数组类分配了内存，则该动态数组类应取消分配内存。

解构函数自然将其默认为成员的解构函数。这样执行会释放动态分配的内存吗？

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

销毁容器。调用这些元素的析构函数，并释放已使用的存储。

事实证明是的，内存确实已释放。这是一个很好的容器设计。

我应该在类的解构函数中调用成员向量的解构函数吗？（请参阅args。〜vector（）; //我应该这样做吗？）

不，您不应该，这是不对的。因为-正如您所说-“解构函数将其称为成员的解构函数作为默认值” 。为了明确起见，在销毁程序的主体执行后，成员总是被销毁。如果还在析构函数的主体内内调用成员的析构函数，则该析构函数将被调用两次，这是非常糟糕的。

隐式析构函数是正确的，对于您的类而言足够了。您无需显式定义它。

几乎不需要显式调用析构函数。销毁超级对象时，将自动调用基本子对象和成员的析构函数。销毁数组时，将自动调用数组元素的析构函数。当自动对象超出范围时，自动对象的析构函数称为 automatically 。在delete表达式中自动调用动态对象的析构函数。在main函数返回后发生的静态销毁过程中，将自动调用静态对象的析构函数。在所有这些情况下，都不需要显式调用析构函数。

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

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

1 个答案: