为什么不使用C ++调用Destructor？

Question

I studding C++ concept. I'm confused in constructor and Destractor concept. Destructor will be invoked implicitly by the compiler upon exit from the program. But in my program, only constructor called.

#include <iostream>
using namespace std;

class A
{
        int i;
public:
        A()
        {
                cout<<"Constructor call"<<endl;
        }
        ~A()
        {
                cout<<"Destructtor call"<<endl;
        }
};

int main()
{
        A *a = new A();
}

Output:

Constructor call

So, I have question : Why destructor not call implicit by the compiler upon exit program?

Answer 1

Why destructor not call implicit by the compiler upon exit program?

Because dynamically allocated objects are not destroyed automatically. That is how the language has been specified. Tracking the destruction of dynamic objects would require runtime / memory overhead.

Solution: Do not leak dynamically allocated objects.

Answer 2

There are 2 "types" of variable lifetime in C++. Dynamic and automatic.

Automatic is something like :

void foo()
{
  int i; // automatic storage
} // destroys i

Here, i will be destructed the moment it leaves scope (after foo returns). You can check this for yourself by making your object have an automatic lifetime:

int main()
{
    A a; // calls A's constructor and allocates memory.
} //calls A's destructor and frees the memory used.

You'll see that both the constructor and the destructor will get called.

---

The second form is dynamically allocated memory. You can dynamically allocate memory by using new (like you did) and free that memory by using delete . The compiler won't do this for you. This means that, to destruct your object you have to call delete explicitly yourself:

int main()
{
        A* a = new A();
        delete a; // calls A's destructor and frees the memory used.
}

If you do not call delete (like your code) then the moment the program leaves main the pointer a is destroyed and now we have a piece of memory that nothing can reach and thus nobody can clean up (with delete ) which means you're leaking memory .

However, modern operating systems reclaim all memory used by the program automatically the moment the program ends so at this point it won't matter too much. This does mean your destructor won't be called as you've just witnessed.

---

Dynamically allocated memory allows you to do some nifty tricks like controlling the lifetime of your objects to the point where you want to destroy them explicitly yourself with delete . The problem with using new and delete is that it's so easy to forget a single delete and your program will already leak memory, which is why it's advised to stay away from this way of allocation.

If for some reason you absolutely need dynamic lifetime then use a smart pointer like std::unique_ptr that will call new and delete for you the moment it goes out of scope.

Answer 3

You create the object dynamically with new . The destructor will only be called when the objected is deleted with delete .

To prevent memory leaks, you could/should use smart pointers like unique_ptr .

In any case, the memory itself will of course be released when the process ends.

Answer 4

The destructor is never called in your code because the object is never destroyed.

You dynamically allocate the A object and you never deallocate it. Add delete a; into main() and you'll see the destructor in action:

int main()
{
    A *a = new A();
    delete a;

    return 0;
}

Answer 5

在主函数中，创建一个指针变量，必须通过在主函数末尾delete a来删除它。

Answer 6

Because you have a memory leak. You dynamically created an object with new , promising that you would manage the lifetime of the object and clean it up later with delete . Then you broke that promise.

If you create an object in the usual fashion:

A a;

then it will be destroyed automatically for you.