首先出现的是析构函数还是 delete() ？ C++

Question

该站点上的许多答案都提到

delete()

调用析构函数。但是下面的示例代码似乎在析构函数中调用了

delete()

。在堆栈和堆中初始化对象时 delete() 的正确用法是什么？

点击查看来源

#include <iostream>
using namespace std;
 
class SmartPtr {
    int* ptr; // Actual pointer
public:
    // Constructor: Refer https:// www.geeksforgeeks.org/g-fact-93/
    // for use of explicit keyword
    explicit SmartPtr(int* p = NULL) { ptr = p; }
 
    // Destructor
    ~SmartPtr() { delete (ptr); }
 
    // Overloading dereferencing operator
    int& operator*() { return *ptr; }
};
 
int main()
{
    SmartPtr ptr(new int());
    *ptr = 20;
    cout << *ptr;
 
    // We don't need to call delete ptr: when the object
    // ptr goes out of scope, the destructor for it is automatically
    // called and destructor does delete ptr.
 
    return 0;
}

Answer 1

当析构函数

SmartPtr

获得控制权

 ~SmartPtr() { delete (ptr); }

它的身体被执行。在正文中，使用了执行的运算符 delete。如果指针

ptr

指向类类型的对象，那么在释放为该对象动态分配的内存之前，将依次调用该类的析构函数。

这里有一个演示程序。

#include <iostream>

int main()
{
    struct A
    {
        ~A() { std::cout << "A::~A() called\n"; }
    };

    struct B
    {
        B() : ptr( new A ) {};
        ~B()
        {
            std::cout << "B::~B() called\n";
            delete ptr;
        }
        A *ptr;
    };

    { 
        B b; 
    }

    std::cout << "That is all!\n";
}

程序输出为

B::~B() called
A::~A() called
That is all!

如果在类的析构函数中删除

B

这个语句

delete ptr;

那么B类的对象就会产生内存泄漏，因为动态分配的类

A

的对象不会被销毁，被它们占用的内存也不会被释放。