destructor

Note: I've seen similar questions, but none of the answers are precise enough, so I'm asking this myself. This is a very nitpicky "language-lawyer" question; I'm looking for an authoritative answer. The C++ standard says: A program may end the lifetime of any object by reusing the storage which the object occupies or by explicitly calling the destructor for an object of a class type with a non-trivial destructor. For an object of a class type with a non-trivial destructor, the program is not required to call the destructor explicitly before the storage which the object occupies is reused or

In C++, if a constructor throws an exception, what destructors are run? In particular, does it make any difference if the exception is during the initialization list or the body? Also, what about inheritance and members? Presumably all completed constructions get destructed. If only some members are constructed, do only those get destructed? If there is multiple inheritance, do all completed constructors get destructed? Does virtual inheritance change anything? if a constructor throws an exception, what destructors are run? Destructors of all the objects completely created in that scope. Does

I know that my destructors are called on normal unwind of stack and when exceptions are thrown, but not when exit() is called. Are there any other cases where my destructors are not going to get called? What about signals such as SIGINT or SIGSEGV? I presume that for SIGSEGV, they are not called, but for SIGNINT they are, how do I know which signals will unwind the stack? Are there any other circumstances where they will not be called? stinky472 Are there any other circumstances where they[destructors] will not be called? Long jumps: these interfere with the natural stack unwinding process and

EDIT : Summary of answers In the following, B is a subclass of A. It's a matter of terminology; ctors and dtors are not inherited, in the sense that the ctor/dtor of B will not be borrowed from A's interface. A class has at least one constructor, and has exactly one destructor. Constructors : B does not inherit constructors from A; Unless B's ctor explicitely calls one of A's ctor, the default ctor from A will be called automatically before B's ctor body (the idea being that A needs to be initialized before B gets created). Destructors : B does not inherit A's dtor; After it exits, B's

Consider this classic example used to explain what not to do with forward declarations: //in Handle.h file class Body; class Handle { public: Handle(); ~Handle() {delete impl_;} //.... private: Body *impl_; }; //--------------------------------------- //in Handle.cpp file #include "Handle.h" class Body { //Non-trivial destructor here public: ~Body () {//Do a lot of things...} }; Handle::Handle () : impl_(new Body) {} //--------------------------------------- //in Handle_user.cpp client code: #include "Handle.h" //... in some function... { Handle handleObj; //Do smtg with handleObj... /

I need to occasionaly create images with rmagick in a cache dir. To then get rid of them fast, without loosing them for the view, I want to delete the image-files while my Ruby Instance of the Image-Class get's destructed or enters the Garbage Collection. What ClassMethod must I overwrite to feed the destructor with code? You can use ObjectSpace.define_finalizer when you create the image file, and it will get invoked when the garbage man comes to collect. Just be careful not to reference the object itself in your proc, otherwise it won't be collected by the garbage man. (Won't pick up