Destructors
 hi(destructor: derived class) of classes are automatically called when an
object is destroyed. This also holds true for objects of classes derived from
other classes. Assume we have the following situation:
        verb(
    class Base
    {
        public:
            ~Base();
    };

    class Derived: public Base
    {
        public:
            ~Derived();
    };

    int main()
    {
        Derived derived;
    }
        )
    At the end of tt(main), the tt(derived) object ceases to exists. Hence,
its destructor (tt(~Derived)) is called. However, since tt(derived) is also a
tt(Base) object, the tt(~Base) destructor is called as well.  The base class
destructor is never explicitly called from the derived class destructor.

Constructors
 hi(constructor: calling order) hi(destructor: calling order) and destructors
are called in a stack-like fashion: when tt(derived) is constructed, the
appropriate base class constructor is called first, then the appropriate
derived class constructor is called. When the object tt(derived) is destroyed,
its destructor is called first, automatically followed by the activation of
the tt(Base) class destructor. A i(derived class destructor) is always called
before its i(base class destructor) is called.

When the construction of a derived class objects did not successfully complete
(i.e., the constructor threw an exception) then its destructor is not
called. However, the destructors of properly constructed base classes em(will)
be called if a derived class constructor throws an exception. This, of course,
is it should be: a properly constructed object should also be destroyed,
eventually. Example:
        verb(
    #include <iostream>
    struct Base
    {
        ~Base()
        {
            std::cout << "Base destructor\n";
        }
    };
    struct Derived: public Base
    {
        Derived()
        {
            throw 1;    // at this time Base has been constructed
        }
    };
    int main()
    {
        try
        {
            Derived d;
        }
        catch(...)
        {}
    }
    /*
        This program displays `Base destructor'
    */
        )





