Is a destructor called when an object goes out of scope?

by

Yes, automatic variables will be destroyed at the end of the enclosing code block. But keep reading.

Your question title asks if a destructor will be called when the variable goes out of scope. Presumably what you meant to ask was:

will Foo’s destructor be called at the end of main()?

Given the code you provided, the answer to that question is no since the Foo object has dynamic storage duration, as we shall see shortly.

Note here what the automatic variable is:

Foo* leedle = new Foo();

Here, leedle is the automatic variable that will be destroyed. leedle is just a pointer. The thing that leedle points to does not have automatic storage duration, and will not be destroyed. So, if you do this:

void DoIt()
{
  Foo* leedle = new leedle;
}

You leak the memory allocated by new leedle.

You must delete anything that has been allocated with new:

void DoIt()
{
  Foo* leedle = new leedle;
  delete leedle;
}

This is made much simpler and more robust by using smart pointers. In C++03:

void DoIt()
{
  std::auto_ptr <Foo> leedle (new Foo);
}

Or in C++11:

void DoIt()
{
  std::unique_ptr <Foo> leedle = std::make_unique <Foo> ();
}

Smart pointers are used as automatic variables, as above, and when they go out of scope and are destroyed, they automatically (in the destructor) delete the object being pointed to. So in both cases above, there is no memory leak.

Let’s try to clear up a bit of language here. In C++, variables have a storage duration. In C++03, there are 3 storage durations:

1: automatic: A variable with automatic storage duration will be destroyed at the end of the enclosing code block.

Consider:

void Foo()
{
  bool b = true;
  {
    int n = 42;
  } // LINE 1
  double d = 3.14;
} // LINE 2

In this example, all variables have automatic storage duration. Both b and d will be destroyed at LINE 2. n will be destroyed at LINE 1.

2: static: A variable with static storage duration will be allocated before the program begins, and destroyed when the program ends.

3: dynamic: A variable with dynamic storage duration will be allocated when you allocate it using dynamic memory allocation functions (eg, new) and will be destroyed when you destroy it using dynamic memory allocation functions (eg, delete).

In my original example above:

void DoIt()
{
  Foo* leedle = new leedle;
}

leedle is a variable with automatic storage duration and will be destroyed at the end brace. The thing that leedle points to has dynamic storage duration and is not destroyed in the code above. You must call delete to deallocate it.

C++11 also adds a fourth storage duration:

4: thread: Variables with thread storage duration are allocated when the thread begins and deallocated when the thread ends.

More Related Contents:

  1. C++ – destructors [closed]
  2. Dynamic memory allocation of array in C & C++
  3. If you shouldn’t throw exceptions in a destructor, how do you handle errors in it?
  4. shared_ptr magic :)
  5. Pure virtual destructor in C++
  6. Object destruction in C++
  7. Is calling destructor manually always a sign of bad design?
  8. calling destructor explicitly
  9. Do I need to explicitly call the base virtual destructor?
  10. Why is the destructor of the class called twice?
  11. What is the use of having destructor as private?
  12. GNU GCC (g++): Why does it generate multiple dtors?
  13. Does std::list::remove method call destructor of each removed element?
  14. Forward declaration with unique_ptr? [duplicate]
  15. Destructors of builtin types (int, char etc..)
  16. Is a Union Member’s Destructor Called
  17. Will an ’empty’ constructor or destructor do the same thing as the generated one?
  18. Is destructor called if SIGINT or SIGSTP issued?
  19. What destructors are run when the constructor throws an exception?
  20. C++ local variable destruction order
  21. Will exit() or an exception prevent an end-of-scope destructor from being called?
  22. How to add constructors/destructors to an unnamed class?
  23. Creating an object: with or without `new` [duplicate]
  24. Pseudo-destructor call does not destroy an object
  25. Why destructor is not called on exception?
  26. problems with Move constructor and Move overloaded assignment operator?
  27. Why does destructor disable generation of implicit move methods?
  28. Under what circumstances are C++ destructors not going to be called?
  29. Are destructors run when calling exit()? [duplicate]
  30. Is the whole object freed with a non-virtual destructor and a Base class pointer?

Leave a Comment