Agfdhyk

Q1: What I also know from practice, is that you cannot initialize a derived object with the same prototype than it's parent constructor without explicitly defining a constructor for the derived class, is that correct?

Other than the trivial case where you've defined a default constructor in the superclass, yes you are correct.

Q2: Can anybody who thinks it's not inherited please explain that?

This may be a matter of definitions of terminology. Whilst it's clear that virtual destructors exist and work "as expected", we see in the C++ standard ([class.virtual]):

Even though destructors are not inherited, a destructor in a derived class overrides a base class destructor declared virtual

(emphasis mine)

Q3: So what happens when you call the constructor of a subclass with inputs? Is the "empty constructor" of the superclass called as well?

If you don't explicitly invoke a specific superclass constructor, then the default superclass constructor will be called (assuming it's visible).

Destructors are not inherited. If a class doesn't define one, the compiler generates one. For trivial cases that destructor just calls the base class' destructor, and often that means that there is no explicit code for its destructor (which imitates inheritance). But if a class has members with destructors, the generated destructor calls destructors for those members before calling the base class' destructor. That's something that an inherited function would not do.

Inheritance is what : mechanism of reusing and extending existing classes without modifying them, thus producing hierarchical relationships between them.

Inheritance is almost like embedding an object into a class.

when class is inheriting a base class then the base class's constructor is called first then derived class's ,and the destructor's call is in reverse order.

So Why Base Class Constructor is called (called not inherited may be with parameters/default) : to guarantees that the base class is properly constructed when the constructor for the derived class is executed.

Now Calling of Destructor (calling not inherit) : when base object get out of scope then the destructor is called on its own.so there is np issue of inheritance of destructor.

now your questions:

ans 1 - yes you are correct for first question.
ans 2 - so destructor is called not inherited after the scope of object goes out.

& ans 3 - if in derived class you are giving the call with parameters then only that constructor would get called , with it no other constructor would get called.


there is no point of issuse that 2 constructor of same object would get called on object creation,as
constructor called at the creation of an object. It prepares the new object for use.so there is no logic of preparing the object twice with different constructors.

Technically, destructors ARE inherited. But in normal circumstances, the inherited destructors are not directly used for a derived class; they're invoked because the derived class's own destructor calls them in order to destroy its own "base class subobjects" as a step within destroying the larger object. And in the unusual circumstances where you do directly use a base class destructor on a derived object, it's very difficult to avoid Undefined Behavior.

This example comes straight from the C++ Standard (12.4p12).

struct B {

  virtual ~B() { }

};

struct D : B {

  ~D() { }

};



D D_object;

typedef B B_alias;

B* B_ptr = &D_object;



void f() {

  D_object.B::~B();              // calls B's destructor

  B_ptr->~B();                   // calls D's destructor

  B_ptr->~B_alias();             // calls D's destructor

  B_ptr->B_alias::~B();          // calls B's destructor

  B_ptr->B_alias::~B_alias();    // calls B's destructor

}

If ~B were not an inherited member of D, the first statement in f would be ill-formed. As it is, it's legal C++, though extremely dangerous.

In your example, you're explicitly calling the destructor functions. This is legal (obviously, since it compiled and ran) but almost always incorrect.

For dynamically-allocated objects created with new, the destructor will be run when the objected is removed with delete.

For statically-allocated objects, which are created simply by declaring the object within the scope of a function, the destructor is run when the object's scope disappears. That is, when main() exits, the objects' destructors will be run. But you've already run the destructors for those objects by calling them manually! This is why your example's output shows the count decreasing to -3... you've run the destructors for a, b, and c twice.

Here's the same code, annotated to show when destructors will be automatically run:

int main()

{

    printf("Create An"); A a;

    printf("Delete An"); a.~A();



    printf("Create Bn"); B b;

    printf("Delete Bn"); b.~B();



    printf("Create new B stored as A*n"); A *a_ptr = new B();

    printf("Delete previous pointern");

    delete a_ptr;   // Implicitly calls destructor for a_ptr.  a_ptr is class B,

       // so it would call a_ptr->~B() if it existed. Because B is an A, after

       // its destructor is called, it calls the superclass's destructor,

       // a_ptr->~A().



    printf("Create Cn"); C c;

    printf("Delete Cn"); c.~C();

}

// Function exits here at the close brace, so anything declared in its scope is

// deallocated from the stack and their destructors run.

// First `c` is destroyed, which calls c.~C(), then because C is a subclass of A

// calls c.~B() (which doesn't exist, so a blank implementation is used), then

// because B is a subclass of A calls c.~A().  This decrements the counter, but

// the count is wrong because you already manually called c.~C(), which you

// ordinarily shouldn't have done.

// Then `b` is destroyed, in a similar manner.  Now the count is off by 2,

// because you had already called b.~B().

// Lastly `a` is destroyed, just as above.  And again, because you had already

// called a.~A(), the count is now off by 3.

I would want to express my thoughts. Creating any object is done in two stages:

1. Allocating area of memory for the object.

2. 
   

   Initializing this area of memory.

   
   
   

   The constructor of object is the function (method) of class (for this object), which initializes allocated area of memory and called automatically.
   The inheritance is embedding the object of the one class to the object of other class. There are plays with poiners "this" "under lid". The "this" is pass on implicitly to the method of class.

   
   
   

   What is happening when the code "B b" is done. Firstly the area of memory is allocated for object b. The class B has own default constructor B(), which is automatically called for initializing this memeory. B() is the function therefore the stack frame is created for working one. This constructor has address of b (implicity). But the object of A must be embedded to the object b. The object of A has no name. Constructor of B knows the noname embedded object of A must be created too (so the compiler C++ works). Therefore the constructor of class A for initializing noname embadded object of class A is called in the constructor of B. The new stack frame is called and noname object is being initialized. After that the stack frames are being closed and our object b of class B has been done. I think that address of b and the noname object coincide.

   
   
   

   The destructor is the method of class too. When we call ~B() the b is not destroyed. The destructor is the function called avtomatically when the object is being destroyed. But it doesn't mean that when we call the destructor the object must be destroyed. If the destructor of B is called, the stack frame is created for one. The default desructor of B knows about the noname embedded object of class A (so the compiler C++ works). Therefore the destructore calls the destructor of A.