c++ - 为包含动态分配的数组成员的类编写析构函数 C++

Question

(C++ 代码)假设我有一个像这样的类:

class A {
public: 
   int * ptr;
   int size;
    A();
    ~A();
}

A::A()
{
    ptr = new int[10];  // memory allocation is dependent upon user input into size variable 
}
A::~A()
{ 
    delete [] ptr; 
}

根据我能找到的内容(示例链接:How delete a pointer of classes which has pointer members?)，这似乎是在此处定义析构函数的正确方法。但是我试过了，它遇到了运行时异常。甚至尝试过，delete ptr; 但没有成功

这是正确的做事方式吗？

队列的基于数组的实现:

#include<iostream>
#include<string>
using namespace std;

class ArrayQueue
{
public:
    int front, size, rear, curr;
    int * elem;
    ArrayQueue():size(10),rear(-1),curr(0),front(-1){}
    ArrayQueue(int n);
    void enqueue(int& e);
    void dequeue();
    bool empty()const;
    int& getFront() const;
    int& getRear() const;
    int& getSize();
    ~ArrayQueue();

};

ArrayQueue::ArrayQueue(int n)
{
    size = n;
    front = -1;
    rear=-1;
    curr=0;
    elem = new int[size];
}
ArrayQueue::~ArrayQueue()
{  cout<<"running destructor";
    delete[] elem;
}

bool ArrayQueue::empty()const
{
    return  curr==0;
}
int& ArrayQueue::getSize()
{
    return curr;
}
int& ArrayQueue::getFront()const
{
    return elem[front];
}
int& ArrayQueue::getRear()const
{
    return elem[rear];
}
void ArrayQueue::enqueue(int& e)
{
    if(getSize()==size){cout<<"Queue full"<<'\n'; return;}
    rear = ((rear+1)%size);
    elem[rear]=e;
    ++curr;
}
void ArrayQueue::dequeue()
{
    if(empty()){cout<<"Queue empty"<<'\n';return;}
    front = ((front+1)%size);
    --curr;
}


int main()
{
    ArrayQueue object;
    cout<<"Size of the queue"<<object.size<<'\n';
    cout<<"Current size:"<<object.getSize()<<'\n';
    object.dequeue();
    for(int i =0 ; i<15; i++)
    {
        object.enqueue(i);
    }
    cout<<"front element : "<<object.front<<'\n';
    cout<<"rear element : "<<object.rear<<'\n';
    cout<<"Current size:"<<object.getSize()<<'\n';
    object.dequeue();
    object.dequeue();
    object.dequeue();
    cout<<"front element : "<<object.front<<'\n';
    cout<<"rear element : "<<object.rear<<'\n';
    return 0;
}

Answer 1

Is this the correct way of doing things?

不，不是在现代 C++ 中。例如，这里有一个问题:如果按原样复制类 A，就会进行所谓的浅复制，并且只复制指针。如果现在其中一个对象超出范围，它会删除数组 ptr，结果是复制的类无法再访问它。

这就是为什么会有“三规则”之类的东西。它指出，如果您需要一个析构函数，您很可能需要自己处理内存布局，因此还需要(至少)一个复制构造函数和一个赋值运算符。在您的情况下，这样的复制构造函数将进行“深层复制”并在复制的类中设置一个新数组，其中包含与原始类中的数组相同的元素。

但这一切都可以在现代 C++ 中避免。

---

被认为是正确的方法是使用自己管理内存分配的成员。执行您想要的操作的最 native 方法是使用 std::array 或 std::vector 而不是 C 样式数组。

struct A
{
   //everything is handled correctly here without destructor, copy constructor, etc.
   //this is an example of RAII or the rule of zero 
   std::vector<int> v;
}

复制、销毁和赋值现在通过调用 std::vector 的相应复制构造函数、析构函数和赋值运算符来执行，您可以确定它已正确实现。因此，如果您复制您的类，您将创建两个不同的 std::vector 对象。

---

另一种选择是使用 std::shared_ptr。

struct A
{
   std::shared_ptr<std::vector<int> > v;   //you could also use an int* here,
                                           //but always prefer std::vector 
}

同样，您无需关心复制、析构函数或赋值的实现，因为您可以依赖它们的默认实现。

如果你复制你的类 A，它又是一个浅拷贝，即你不复制 shared_ptr 指向的对象，而只是指针。但是，现在 shared_ptr 计算指向托管 std::vector 的实例数，并防止复制的类在超出范围时删除托管对象。

---

您需要哪些替代方案取决于您的要求。在每种情况下，您都应该熟悉这些概念，因为在我看来它们在 C++ 中非常重要。