When is a C++ destructor called?

by

1) If the object is created via a pointer and that pointer is later deleted or given a new address to point to, does the object that it was pointing to call its destructor (assuming nothing else is pointing to it)?

It depends on the type of pointers. For example, smart pointers often delete their objects when they are deleted. Ordinary pointers do not. The same is true when a pointer is made to point to a different object. Some smart pointers will destroy the old object, or will destroy it if it has no more references. Ordinary pointers have no such smarts. They just hold an address and allow you to perform operations on the objects they point to by specifically doing so.

2) Following up on question 1, what defines when an object goes out of scope (not regarding to when an object leaves a given {block}). So, in other words, when is a destructor called on an object in a linked list?

That’s up to the implementation of the linked list. Typical collections destroy all their contained objects when they are destroyed.

So, a linked list of pointers would typically destroy the pointers but not the objects they point to. (Which may be correct. They may be references by other pointers.) A linked list specifically designed to contain pointers, however, might delete the objects on its own destruction.

A linked list of smart pointers could automatically delete the objects when the pointers are deleted, or do so if they had no more references. It’s all up to you to pick the pieces that do what you want.

3) Would you ever want to call a destructor manually?

Sure. One example would be if you want to replace an object with another object of the same type but don’t want to free memory just to allocate it again. You can destroy the old object in place and construct a new one in place. (However, generally this is a bad idea.)

// pointer is destroyed because it goes out of scope,
// but not the object it pointed to. memory leak
if (1) {
 Foo *myfoo = new Foo("foo");
}


// pointer is destroyed because it goes out of scope,
// object it points to is deleted. no memory leak
if(1) {
 Foo *myfoo = new Foo("foo");
 delete myfoo;
}

// no memory leak, object goes out of scope
if(1) {
 Foo myfoo("foo");
}

More Related Contents:

  1. C++ – destructors [closed]
  2. Dynamically allocating an array of objects
  3. shared_ptr magic :)
  4. Pure virtual destructor in C++
  5. Why do we need a 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. When is an object “out of scope”?
  12. Does std::list::remove method call destructor of each removed element?
  13. Forward declaration with unique_ptr? [duplicate]
  14. Is it possible to delete a non-new object?
  15. Does delete on a pointer to a subclass call the base class destructor?
  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 a destructor called when an object goes out of scope?
  19. Is destructor called if SIGINT or SIGSTP issued?
  20. What destructors are run when the constructor throws an exception?
  21. C++ local variable destruction order
  22. Why do un-named C++ objects destruct before the scope block ends?
  23. Why, really, deleting an incomplete type is undefined behaviour?
  24. Creating an object: with or without `new` [duplicate]
  25. Pseudo-destructor call does not destroy an object
  26. Why destructor is not called on exception?
  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