析构函数和解除分配的函数有什么区别？

Question

这段代码中的析构函数和DeAllocate函数有什么区别？

我不明白它们看起来是一样的 me.They 做完全相同的事情，为什么您需要像 DeAllocate 这样的函数？析构函数有自动调用的好处，但 DeAllocate 没有。

#include <iostream>
using namespace std;

const int SIZE=5;

class ARRAY_CLASS
{
public:
    ARRAY_CLASS();//default constructor
    ~ARRAY_CLASS(); //destructor
    void Add(int); //mutator
    void Print(); //accessor
    int * Get_Address(); //accessor
    void DeAllocate(); //mutator
private:

    int *A;
    int count;
};

ARRAY_CLASS::ARRAY_CLASS()
{
    cout<<"Default constructor has been called\n";
    A = new int[SIZE];
    count = 0;
}


ARRAY_CLASS::~ARRAY_CLASS()
{
    cout<<"The Destructor has been Called!\n";
    delete [ ] A;
    A=0;
    count = 0;
}

void ARRAY_CLASS::Add(int item)
{
    if (count<SIZE)
        A[count++]=item;
    else
        cout<<"Array Full\n";
}
void ARRAY_CLASS::Print()
{
    for(int i=0; i<count; i++)
        cout<<"A[i] = "<<A[i]<<endl;
}

int * ARRAY_CLASS::Get_Address()
{
    return A;
}

void ARRAY_CLASS::DeAllocate()
{
    delete [ ] A;
    A = 0;
    count = 0;
}

int main()
{

    ARRAY_CLASS B;

    B.Add(1);
    B.Add(2);
    B.Add(3);
    B.Add(4);
    B.Add(5);

    B.Print();

    ARRAY_CLASS A = B;

    cout<<"A holds address location = "<<A.Get_Address()
    <<" and B holds address location "<<B.Get_Address()<<endl;

    B.DeAllocate();
    A.Print();

    return 0;
}

Answer 1

析构函数将在对象本身被删除时发生。

在您发布的示例中，您可以简单地将该函数重命名为其他名称，比如 void ARRAY_CLASS::ClearArray() 而不是 void ARRAY_CLASS::DeAllocate()。您所做的只是释放 A 使用的内存，而不是破坏整个对象。

Answer 2

确实可以重写析构函数：

ARRAY_CLASS::~ARRAY_CLASS()
{
    cout<<"The Destructor has been Called!\n";
    DeAllocate();
}

区别在于：

析构函数在销毁时被调用（在离开创建对象的范围时自动为本地对象调用，或者为自由存储对象在对象被删除时调用）。对象被销毁后，对象不复存在。
当你调用DeAllocate();时，数组的内存被释放，对象的状态发生变化，但它的所有成员和ARRAY_CLASS对象本身仍然存在。

析构函数和解除分配的函数有什么区别？

What is the difference between a destructor and a funtion that deallocates?

c++

oop

destructor

object-lifetime