c++ - 定义类 X 的析构函数，它继承自指向对象 Y 的指针 vector 并具有指向 Z 的指针数组

Question

因此，我会尽可能清楚地说明这一点。假设我们有以下内容:

class X : protected vector<objectY*> 
{
private:
objectZ** array;
unsigned size;
unsigned capacity;

public:
X():size(0), capacity(0), array(new objectZ*[100]){}
X(const objectX& o); // to be defined later 
X& operator=(const X& x); //defined later
~X(){ delete [] array; clear(); } <--- is this correct, or it produces memory leak?
void add(objectZ* o); // used to add objects to array

} 

现在假设我们已经定义了类 Y 和 Z，其中包含编译上述代码所需的所有基本内容。我的问题如下: 析构函数是否正确？我的代码有内存泄漏吗？

假设我转到 main() 并执行此操作:

objectZ* o1 = new objectZ();
objectX* x1 = new objectX();

x1->add(o1);

 delete o1; // to avoid memory leak;
return 0; // end of main.

因为我主要从 main 添加内容到 objectX 的数组，而且很可能使用多态性，比如

 objectZ* ok = new objectK(); // where k is derived from Z
 x1->add(ok);

我如何在没有内存泄漏的情况下正确定义类 X 的析构函数，并考虑到它也继承自指向另一个对象 Y 的指针 vector ，我是否需要将 vector 1 个元素循环并对其调用 delete，以及最后是 clear() 还是 clear() 就足够了？我是否也循环数组并对它的元素调用 delete ？我的想法是，因为我没有从 X 类中分配内存，所以我也不需要取消分配它。我只需要删除 [] 数组，并可能清除()继承的 vector 。

Answer 1

Is the destructor correct? Does my code have memory leak?

可能吧。如果 X 应该取得其数组中 objectZ 对象的所有权，那么它需要先释放这些对象，然后再释放数组本身，否则它们就会被泄露。

附带说明一下，您的 main() 示例正在泄漏 x1 对象。目前尚不清楚您是否打算调用 delete x1 而不是 delete o1，或者 x1->add(o1) 是否应该采用是否拥有 o1。

how do I define properly the destructor of class X without having memory leaks

首先不进行手动内存管理。适当使用智能指针、std::unique_ptr 和 std::shared_ptr，让它们为您处理内存管理。

considering it also inherits from a vector of pointers to another objectY, do I need to cycle the vector 1 by 1 element and call delete on it

很有可能，是的。这实际上取决于 X 采用的所有权模型。如果 X 取得了 objectY 和 objectZ 对象的所有权，则它负责释放它们。否则，如果它不取得所有权，则不负责释放它们。

and clear() at the end or is clear() enough?

对于原始指针数组，clear() 只是从数组中删除指针，它不会释放指向的对象。另一方面，当从数组中删除智能指针时，智能指针数组将释放对象。

My thoughts are that since I'm not allocating memory from within class X, I don't need to deallocate it either.

任何用 new 分配的对象都必须用 delete 释放。这是否需要在 X 内部发生将取决于 X 的特定所有权模型。