How does C++ automatically call destructor?

Question

In C++, we can manage resources by objects, i.e. acquiring resource in Ctor, and releasing it in Dtor (RAII). This relies on C++'s automatic destructor invocation. But how is this done under the hood? For example, how C++ know to call Dtor for c1 but not c2. (I know this must have been answered before, but all of my searches ended in topics explaining how to use RAII). Thanks!

class Cat;
Cat c1;
Cat* c2 = new Cat();

Edit: I know I need to call delete for c2. I just don't understand how Dtor is called when c1 goes out of scope.

GCC is free software, Clang is open-source. Go and find out. — StoryTeller - Unslander Monica, Aug 29 '17 at 13:10
You got it backwards, in your example `c1`'s destructor will be called (when it goes out of scope), not `*c2`'s. That's why `new` is seldom used in modern c++ (search for "c++ smart pointer" in your search engine of choice). — spectras, Aug 29 '17 at 13:10
It's done because the C++ standard says it must be done. And how it's done is by having your C++ compiler generate compiled code that complies to the C++ standard. — Sam Varshavchik, Aug 29 '17 at 13:11
@rzmn Use `std::unique_ptr` to have the destructor automatically called. — user0042, Aug 29 '17 at 13:17
The destructor is automatically called when the `scope` of a variable ends... — Elvis Dukaj, Aug 29 '17 at 13:19
The destructor is called for `c2` too, just not the `Cat` destructor but the `Cat*` destructor, which is trivial. — Hatted Rooster, Aug 29 '17 at 13:19
Possible duplicate of [Is a destructor called when an object goes out of scope?](https://stackoverflow.com/questions/17702936/is-a-destructor-called-when-an-object-goes-out-of-scope) — Andre Kampling, Aug 29 '17 at 13:27
@Rick so Dtor is called for EVERY object/pointer/(what else?) that resides on stack? — havij, Aug 29 '17 at 13:30
Pointer don't have destructors. Neither do built in types. All the rest (every custom struct or class) do and does get called. Probably POD's don't either. In general everything is destroyed once it goes out of scope. Destroying a pointer however does not call the destructor of what it points to. — rozina, Aug 29 '17 at 13:35
You forgot to `delete` your object. You should *always* call `delete` when you are finished with the object. — Thomas Matthews, Aug 29 '17 at 14:14
@rzmn> what Rick meant is the pointer `c2` is disposed of. **Not** the pointed object. — spectras, Aug 29 '17 at 16:09
@rozina conceptually, they do. Its just they are defined to be *trivial*. It's much easier to define it that way so that you can say things like "`template struct Thing { T member; }` has an implicitly declared destructor, which is trivial if `T`'s destructor is trivial ..." Rather than "... which is trivial if `T`'s destructor is trivial, or `T` is a pointer, or arithmetic, or array of trivially destructible, or ... type" — Caleth, Mar 13 '18 at 10:45
@Caleth I don't think they do though. You cannot call an int's destructor. You can however call it's constructor. [Excample code](http://cpp.sh/6izls) — rozina, Mar 13 '18 at 14:08
@rozina [Calling ~int()](http://coliru.stacked-crooked.com/a/00acfa7ae4a3f268) — Caleth, Mar 13 '18 at 15:06

Paul Floyd · Accepted Answer · 2020-04-22T08:47:14.487

Take a look at compiler explorer. I've linked a buildable version of your example. Just in case the link is not permanent, I've copied the code at the end if this answer.

For the Cat c1; line (in light red) you will see that there are three corresponding blocks in the asm, same colour.

lea rax, [rbp-28]
mov rdi, rax
call Cat::Cat()

This matches the construction of the object on the stack.

Next there is

lea rax, [rbp-28]
mov rdi, rax
call Cat::~Cat()

This is the normal return path, calling the destructor automatically.

Finally there is

lea rax, [rbp-28]
mov rdi, rax
call Cat::~Cat()
mov rax, rbx
mov rdi, rax
call _Unwind_Resume

This is the path taken if an exception is thrown (e.g., by new). It automatically calls the destructor and then continues the exception.

For the sake of completeness, here is the C++ source code:

    class Cat
    {
    public:
        Cat() : meow() {}
        ~Cat() {}
    private:
        int meow;
    };

    void foo()
    {
        Cat c1;
        Cat* c2 = new Cat();
    }

    int main()
    {
        foo();    
    }

+1 for compiler explorer. In particular since you can easily add more complex control flow to the code and see how the generated destructor calls move around. — ComicSansMS, Aug 29 '17 at 13:30

How does C++ automatically call destructor?

1 Answers1