Наследование - вызов конструкторов и деструкторов

class class_1_type {
private:
    int t;
public:
    class_1_type(int t_) { t = t_; cout << "class_1. object: " << this << " - constructor  t = " << t << endl; }
    ~class_1_type() { cout << "class_1. object: " << this << " - destructor  t = " << t << endl; }
};
 
 
class class_2_type: public class_1_type {
private:
    int s;
public:
    class_2_type(int t_, int s_): class_1_type(t_) { s = s_; cout << "class_2. object: " << this << " - constructor  s = " << s << endl; }
    ~class_2_type() { cout << "class_2. object: " << this << " - destructor  s = " << s << endl; }
};

    class_1_type * ob1;
    class_2_type * ob2;
 
    ob1 = new class_1_type(1);
    delete ob1;
 
    ob1 = new class_2_type(2, 3);
    delete ob1;
 
    ob2 = new class_2_type(4, 5);
    delete ob2;

~class_1_type()

virtual ~class_1_type()

#include <cstdio>
 
struct base
{
    virtual ~base() {}
};
 
struct child : base
{
    ~child()
    {
        printf("child destructor\r\n");
    }
};
 
struct grandchild : child
{
    ~grandchild()
    {
        printf("grandchild destructor\r\n");
    }
};
 
int main()
{
    base * Child = new child();
    base * GrandChild = new grandchild();
    delete GrandChild;
    delete Child;
    return 0;
}

......
class_2_type(int t_, int s_): class_1_type(t_) { s = s_; cout << ......
......

struct A
{
    virtual ~A() {}
};
struct B : A
{
    ~B() override {}
 
};

using namespace std;
class Base{
   public:
    void print(){
        out();
    }
 
private:
    virtual void out(){
        cout<<"base"<<endl;
    }
};
class Derived:public Base{
private:
    virtual void out(){
        cout<<"derived"<<endl;
    }
};
 
int main()
{
    Base a;
    Base *pa;
 
 
    Derived d;
 
 
    pa = &d;
    a.print();
    pa->print();
 
 
    return 0;
}

class A_impl: public B_type {
};