c ++：如何为结合指针的向量编写析构函数

Question

我需要为学校练习编写一个析构函数。我已经尝试为A类编写析构函数，这是对还是错？

Exercise on paper

练习说析构函数需要像这样开始：

A *pa = .......;
delete pa;

4个类的代码：

Class A
{
  private:
    vector <B*> b;
    vector <C*> c;
  public:
    ~A();
}

Class B
{
  private:
    vector <D*> d;
  public:
    ~B();
}

Class C
{
  private:
    vector <D*> d;
  public:
    ~C();
}

Class D
{
  private:
    vector <A*> a;
  public:
    ~D();
}

我已经尝试为 A 类编写析构函数， 这是正确的方法吗？

~A()
{
  for (int i = 0; i < b.size(); i++)
  {
     B* pa = b[i];
     delete pa;
  }

  for (int j = 0; j < c.size(); i++)
  {
    C* pa = c[i];
    delete pa;
  }

Answer 1

假设你不确定A类中的两个vectors中的指针都是不是NULL，那么你可以这样做：

~A()
{
  for (int i = 0; i < b.size(); i++)
    delete b[i];
  b.clear(); // Making sure you do not access to deleted pointers

  for (int i = 0; i < c.size(); i++)
    delete c[i];
  c.clear();  // Making sure you do not access to deleted pointers
}

我们还清除了向量，以确保不会访问已删除的点。或者，如果您仍然需要向量的大小，您可以设置 b[i] = nullptr 和 c[i] = nullptr 在两个循环中，不清除向量。

Answer 2

这取决于构造函数的作用。

一般来说，就是说构造函数建立一个类不变量（一组所有成员函数都可以假设为真的属性），所有在类外部使用的成员函数（例如公共成员，提供服务的受保护成员）到派生类）保持不变。析构函数的作用与构造函数的相反——例如，如果构造函数显式分配了一些资源，析构函数就会释放它。

如果该不变量包括“b 的所有元素都分配了运算符 new 的结果”，则析构函数必须使用（相应的运算符 delete 释放这些元素，或者移交给其他执行此操作的对象所以。这通常被描述为所有权 - 类 A 采取影响其他对象生命周期的操作，因此必须清理。

如果该不变量包括“c 的所有元素要么是 NULL 指针，要么包含从其他地方提供的对象的地址”，那么析构函数不应释放这些对象。例如，其他一些代码可能会提供一个指向A 的成员函数的指针，而该指针只是简单地放在c 中。这假设您知道这些对象的生命周期是在您的类之外管理的 A。

例如，考虑一个执行此操作的构造函数

 A::A(int num_b, const std::vector<C *> &in_c) : b(0), c(in_c)
 {
     b.reserve(num_b);    // so b doesn't keep on resizing itself below
     for (int i = 0; i < num_b; ++i)
        b.push_back(new B);
 }

其逻辑是A 正在分配地址存储在b 中的所有对象，但只是从in_c 复制指针（可能在其他地方管理）。所以A 类负责b 中对象的生命周期，但不负责c 中的对象的生命周期。

然后我们假设，如果成员函数更改 b 或 c，当调用 As 析构函数时，同样适用 - b 中的所有对象都由类 A 管理，但在c 不是。 （换句话说，我们假设类不变量被保持）。

那么析构函数可能看起来像

 A::~A()
 {
     for (std::vector<B *>::iterator i = b.begin(), end = b.end();
          i != end;
          ++i)
     {
          delete (*i);
     }
 }

请注意，我们不需要调整b 或c 的大小，因为std::vector 的析构函数会自行清理。但是，由于我们的类分配了对象并将它们的地址存储在 b 中 - std::vector 不知道 - 析构函数必须释放它们。

注意：以上示例适用于所有版本的 C++。在 C++11 之后，析构函数中的代码可以简化，例如使用新样式的循环或auto 类型推导。

Answer 3

这取决于。如果A 拥有向量中的指针，因此负责销毁指向的对象并且对象是使用new 创建的，那么是的，析构函数似乎是正确的。

如果指向的对象不是用new 创建的，或者指针不拥有为A，那么A 的析构函数不应该删除它们。

如果A 确实拥有指针，那将是糟糕的设计，不要在A 类中分配对象。但我认为，为了简单起见，示例中没有提及。

附带说明：如果 A 确实拥有指针并在析构函数中删除它们，那么您还应该实现复制构造函数和复制赋值运算符，以便它们进行深度复制或使类不可复制.否则，如果您复制实例，最终会出现未定义的行为。

但是正如你在B类和C类中看到的那样，我去D类，但是如果我删除D会出现错误？

这样做完全没问题，除非...

...如果A拥有指向B和C的指针，并且B和C拥有指向D的指针，并且D拥有指向A的指针，这样他们都删除了指向的对象，然后在类级别上有一个所有权周期。除非...

...有一个指针循环。例如，D 的一个实例（我们称它为dee）指向一个A 的实例，该实例指向一个B 的实例，该实例指向dee，那么你有一个循环，你结束了删除析构函数已经启动的对象，这会导致未定义的行为。

所以，如果这样的指针循环是可能的，那么必须避免所有权循环。但是如果不能有指针循环，那么就可能存在所有权循环。