迹忆客 专注技术分享

在使用任何编程语言进行编程时，我们经常听到构造函数和析构函数。 构造函数是用于初始化类对象的特殊成员函数，而析构函数也是在对象要被销毁时自动调用的特殊函数。

本文将详细讨论 C++ 中动态数组的析构函数。

C++ 动态数组的析构函数

析构函数是与类同名的特殊成员函数，当对象要被销毁时会自动调用。

析构函数是对象被销毁时调用的最后一个函数。 它清理构造函数创建的对象占用的内存。

但是，构造函数和析构函数都与类的名称相同，但是两者在写法上有所不同，以便编译器可以区分它们。 析构函数使用否定符号 (~) 后跟类名编写，而构造函数仅使用类名。

而且，一个类只能有一个析构函数，但构造函数可以有多个。

C++中每当创建一个对象时，它都会占用堆段的内存，我们使用 new 关键字来动态创建该类的那个对象。 同样，delete 关键字用于删除类动态创建的对象。

在 C++ 中需要析构函数

我们需要删除该对象以避免任何内存泄漏。 当程序员忘记删除堆中未使用的内存时，就会发生内存泄漏。 因此，计算机的性能会随着可用内存量的减少而降低。

此外，如果没有使用析构函数显式删除对象，程序将在运行时崩溃。

C++ 中的析构函数示例

现在，让我们看一些如何使用 delete 运算符删除类对象的示例。

示例 1：

在第一个示例中，我们将使用 new 运算符动态创建类的对象，并使用 C++ 中的 delete 关键字显式删除它。

下面是在 C++ 中使用删除运算符的代码示例。

#include <iostream>
using namespace std;

class Employee {
public:
    Employee()
    {
        cout << "Constructor of Employee class was called!\n";
    }
    ~Employee()
    {
        cout << "Destructor of Employee class was called!\n";
    }
    void work()
    {
        cout << "Still Working!\n";
    }
};
int main()
{
    Employee* emp = new Employee();
    emp->work();
    delete emp;

    return 0;
}

输出结果:

Constructor of Employee class was called!
Still Working!
Destructor of Employee class was called!

在上面的示例中，我们创建了一个 Employee 类，它具有构造函数、析构函数和包含有关其操作的适当消息的工作函数。

在 main 函数中，我们使用 new 关键字创建了类 emp 的对象，并用它调用了 work() 函数。 之后，我们只使用删除运算符和对象名称 emp 来删除相同的内容。

在 C++ 中使用析构函数删除动态数组

到目前为止，我们已经了解了如何使用 C++ 中的 delete 关键字删除一个类的单个对象。 现在，让我们看看如何在 C++ 中删除动态数组或对象数组。

在此示例中，我们将使用 new 关键字在 C++ 中创建一个动态数组，然后使用 delete 运算符将其删除。

但是，在 C++ 中删除动态数组时要记住的一件事是，我们必须使用 delete [] 运算符来执行此操作，而不仅仅是删除。 因此，delete 运算符用于删除类的单个对象，而要删除动态数组或对象数组，我们必须使用 C++ 中的 delete [] 运算符。

现在，让我们借助代码示例来理解它。

#include <iostream>
using namespace std;
class Employee {
public:
    Employee()
    {
        cout << "Constructor of Employee class was called!\n";
    }
    ~Employee()
    {
        cout << "Destructor of Employee class was called!\n";
    }
    void work()
    {
        cout << "Still working!\n";
    }
};
int main()
{
    Employee* emp = new Employee[3];
    emp[0].work();
    emp[1].work();
    emp[2].work();

    delete[] emp;

    return 0;
}

输出结果:

Constructor of Employee class was called!
Constructor of Employee class was called!
Constructor of Employee class was called!
Still working!
Still working!
Still working!
Destructor of Employee class was called!
Destructor of Employee class was called!
Destructor of Employee class was called!

在这个代码示例中，我们有与前面示例类似的代码，但是这次，我们创建了三个 Employee 对象，并使用 c++ 中的 delete [] 运算符删除了它们。

但是，如果我们使用 delete 运算符而不是 delete []，程序会在运行时崩溃。 让我们再看一个例子，以便更清楚地理解 C++ 中动态数组的删除。

#include <iostream>
using namespace std;
class Employee {
public:
    Employee()
    {
        cout << "Constructor of Employee class was called!\n";
    }
    ~Employee()
    {
        cout << "Destructor of Employee class was called!\n";
    }
    void work()
    {
        cout << "Still working!\n";
    }
};
int main()
{
    Employee* emp = new Employee[3];
    emp[0].work();
    emp[1].work();
    emp[2].work();

    delete emp;

    return 0;
}

输出结果:

Error in `./example1.cpp': munmap_chunk(): invalid pointer: 0x000000000117f018 ***
timeout: the monitored command dumped core
/bin/bash: line 1:    33 Aborted                 timeout 15s ./0f6c05b9-ee09-44c3-acee-8ad8a882ac5e < 0f6c05b9-ee09-44c3-acee-8ad8a882ac5e.in

Constructor of Employee class was called!
Constructor of Employee class was called!
Constructor of Employee class was called!
Still working!
Still working!
Still working!
Destructor of Employee class was called!

因此，正如您在上面的输出中看到的，构造函数和函数工作已为所有三个对象调用，但析构函数仅为单个对象调用一次，之后程序崩溃。

总结

在本文中，我们讨论了 C++ 中动态数组的析构函数。 析构函数是特殊的成员函数，当要删除对象时会自动调用它们。

我们使用 delete 运算符来删除一个类的对象； 但是，它只删除一个类的单个对象。 要删除动态数组或对象数组，我们使用 delete [] 运算符。

本文中已通过适当的示例解释了运算符及其用法。