【C++第十课】---继承中的构造与析构

一、继承中的赋值兼容性原则

1.子类对象可以当作父类对象使用

2.子类对象可以直接赋值给父类对象

3.子类对象可以直接初始化父类对象

4.父类指针可以直接指向子类对象

5.父类引用可以直接引用子类对象

6.子类是就是特殊的父类。

举例说明：

#include <iostream>
using namespace std;
class Parent
{
       protected:
              const char* name;
       public:
              Parent()
              {
                     name= "Parent ...";
              }
              void print()
              {
                     cout<<"Name= "<<name<<endl;
              }
};
class Child:public Parent
{
       protected:
              int i;
       public:
              Child(int i)
              {
                     name= "Child ...";
                     i= i;
              }

};
int main(int argc, char** argv)
{
       ParentPobj;
       Child  Cobj(1);
       Pobj= Cobj;       //子类对象可以直接赋值给父类对象
       Parent*pp = &Cobj; //父类指针可以直接指向子类对象
       Parent&p_p = Cobj; //父类引用可以直接引用子类对象

       ParentPPobj = Cobj;
return 0;
}

二、继承对象的模型

1.类在C++编译器的内部可以理解为结构体

2.子类是由父类成员叠加子类新成员得到的

问题的引入：

1.如何初始化父类成员？

2.父类与子类的构造函数有什么关系？

解答：

1.在子类对象构造的时候需要调用父类构造函数对其继承得来的成员进行初始化

2.在子类对象析构的时候需要调用父类析构函数对其继承得来的成员进行清理

一个实例：

#include <iostream>

using namespace std;

class Parent
{
       public:
              Parent()
              {
                     cout<<"Parent()..."<<endl;
              }
              ~Parent()
              {
                     cout<<"~Parent()..."<<endl;
              }
};
class Child:public Parent
{
   public:
              Child()
              {
                     cout<<"Child()..."<<endl;
              }
              ~Child()
              {
                     cout<<"~Child()..."<<endl;
              }
};
void func()
{
       Child  Cobj;
}
int main(int argc, char** argv)
{
   func();
       cin.get();
       return0;
}

打印结果：

总结起来就是：

1.子类对象在创建时会首先调用父类的构造函数

2.父类构造函数执行结束后，执行子类的构造函数

3.当父类的构造函数有参数时，需要在子类的初始化列表中显示调用

4.析构函数调用的先后顺序与构造函数相反

既然提到初始化列表，把么我们来看看一个初始化列表的例子：

三、如何使用初始化列表

#include <iostream>

using namespace std;

class Parent
{
       public:
              Parent(const char* s)
              {
                     cout<<"Parent()..."<<endl;
                     cout<<s<<endl;
              }
              ~Parent()
              {
                     cout<<"~Parent()..."<<endl;
              }
};
class Child:public Parent
{
   public:
              Child():Parent("Para fromchild")
              {
                     cout<<"Child()..."<<endl;
              }
              ~Child()
              {
                     cout<<"~Child()..."<<endl;
              }
};
void fun()
{
       Child  Cobj;
}
int main(int argc, char** argv)
{
   fun();
       cin.get();
       return0;
}

类中的成员变量可以是其它类的对象。

那么问题来了：

如果一个类继承自父类并且有其它的对象作为成员，那么构造函数如何调用?

口诀：先父母，后客人，再自己。

四、同名成员变量

当子类中定义的成员变量与父类中的成员变量同名时会发生什么？

1.当子类成员变量与父类成员变量同名时

2.子类依然从父类继承同名成员

3.在子类中通过作用域分别符::进行同名成员区分

4.同名成员存储在内存中的不同位置

五、继承深度实例

#include <cstdlib>
#include <iostream>
using namespace std;
class Object
{
public:
   Object(const char* s)
    {
       cout<<"Object()..."<<""<<s<<endl;
    }
};

class Parent : public Object
{
public:
   Parent(const char* s) : Object(s)
    {
       cout<<"Parent()..."<<""<<s<<endl;
    }
};

class Child : public Parent
{
protected:
   Object o1;
   Object o2;
public:
   Child() : o2("o2"), o1("o1"), Parent("Parameterfrom Child!...")
    {
        cout<<"Child()..."<<endl;
    }
};

void fun()
{
   Child child;
}

int main(int argc, char *argv[])
{
   fun();
   cin.get();
   return 0;
}

打印内容：

依据的口诀就是 ：先父母，后客人，再自己。

六、总结

1.子类对象可以当作父类对象使用

2.子类对象在创建时需要调用父类构造函数进行初始化

3.子类对象在销毁时需要调用父类析构函数进行清理

4.先执行父类构造函数，再执行成员构造函数

5.在继承中的析构顺序与构造顺序对称相反

6.同名成员通过作用域分辨符进行区分