关于析构函数调用的困惑

Question

Does a destructor gets called before an object is destroyed or after an object is destroyed? I think that it is called before an object is destroyed because after an object is destroyed we cant access that memory to free any resource in there but if I am wrong then please correct me so I can understand it well

#include <iostream>
#include <cassert>
#include <cstddef>
class Check
{
public:
    int neu{};
    Check() = default;
    Check(int n)
    {
        neu = n;
    }
    void print()
    {
        std::cout << neu << std::endl;
    }
    ~Check()
    {
        std::cout << "It has been destroyed "<<neu <<std::endl;
    }
};
int main()
{
    Check let,see(30);
    let.print();
    return 0;
    // does destructor gets called here
} // or does destructor gets called herecode here

Answer 1

Does a destructor gets called before an object is destroyed or after an object is destroyed?

The lifetime of the object has ended when the destructor is called. The object is destroyed by the destructor.

    // does destructor gets called here
} // or does destructor gets called herecode here

There's really no practical difference.

The automatic objects are alive within the block and they aren't alive outside the block. The objects are destroyed when the block is exited. As such, it is reasonable to say that they are destroyed at the point where the closing brace is.

Answer 2

From ISO standard ( Special member functions - Destructors ):

Once a destructor is invoked for an object, the object no longer exists; the behavior is undefined if the destructor is invoked for an object whose lifetime has ended.

Destructor call is essentially description of actions need to consider object destroyed. Destructor can be called explicitly, it results in end of life for that object. Explicit calls are rare, usually done for objects created by placement new.

Given the example provided, the question is actually about order of destructor calls. The destructors for sub-objects ( base class-type included, if any present) are called after. So you can safely access them until exit from destructor. Order of call is based on declaration order, just like order of initialization but inverted. Subobject of base-class type is considered the first for initialization and the last for destruction.