---

关于继承

我们发现，定义一些类时，下级别的成员处理拥有上一级的共性，还有自己的特性。
这时候我们就可以考虑利用继承的技术，减少重复代码。

继承的好处：减少重复代码

语法：
class 子类 : 继承方法 父类；
如：class A:public B;
A类称为子类或派生类
B类称为父类或基类

派生类中的成员包含两大部分：
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过来的表现其共性，而新增的成员体现了其个性。

继承与非继承的对比

非继承方式实现：

#include<iostream>
using namespace std;//Java页面
class Java
{
public:void header(){cout << "首页、公开课、登录...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;}void left(){cout << "Java、Python、C++...（公共分类列表）" << endl;}void content(){cout << "Java学科视频" << endl;}
};//Python页面
class Python
{
public:void header(){cout << "首页、公开课、登录...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;}void left(){cout << "Java、Python、C++...（公共分类列表）" << endl;}void content(){cout << "Python学科视频" << endl;}
};//C++页面
class Cpp
{
public:void header(){cout << "首页、公开课、登录...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;}void left(){cout << "Java、Python、C++...（公共分类列表）" << endl;}void content(){cout << "C++学科视频" << endl;}
};void test()
{//Java页面cout << "Java下载视频页面如下：" << endl;Java ja;ja.header();ja.footer();ja.left();ja.content();cout << "-----------" << endl;//Python页面cout << "Python下载视频页面如下：" << endl;Python py;py.header();py.footer();py.left();py.content();cout << "-----------" << endl;//C++页面cout << "C++下载视频页面如下：" << endl;Cpp cp;cp.header();cp.footer();cp.left();cp.content();
}int main()
{test();system("pause");return 0;
}

继承方式实现：

#include<iostream>
using namespace std;//公共页面
class BasePage
{
public:void header(){cout << "首页、公开课、登录...（公共头部）" << endl;}void footer(){cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;}void left(){cout << "Java、Python、C++...（公共分类列表）" << endl;}
};//Java页面
class Java :public BasePage
{
public:void content(){cout << "Java学科视频" << endl;}
};//Python页面
class Python :public BasePage
{
public:void content(){cout << "Python学科视频" << endl;}
};//C++页面
class Cpp :public BasePage
{
public:void content(){cout << "C++学科视频" << endl;}
};void test()
{//Java页面cout << "Java下载视频页面如下：" << endl;Java ja;ja.header();ja.footer();ja.left();ja.content();cout << "-----------" << endl;//Python页面cout << "Python下载视频页面如下：" << endl;Python py;py.header();py.footer();py.left();py.content();cout << "-----------" << endl;//C++页面cout << "C++下载视频页面如下：" << endl;Cpp cp;cp.header();cp.footer();cp.left();cp.content();
}int main()
{test();system("pause");return 0;
}

继承方式

继承的语法：class 子类 : 继承方式 父类

C++中的继承方式有：
public、private、protected三种
（它们直接影响到派生类的成员、及其对象对基类成员访问的规则）
（1）public（公有继承）：
继承时保持基类中各成员属性不变，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象只能访问基类中的public成员。
（2）protected（保护性继承）：
继承时基类中各成员属性均变为protected，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象不能访问基类中的任何的成员。
（3）private（私有继承）：
继承时基类中各成员属性均变为private，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象不能访问基类中的任何的成员。

#include<iostream>
using namespace std;class dad
{
public:int m_A;
protected:int m_B;
private:int m_C;
};class son1 :public dad
{
public:void func(){m_A = 10;//父类中的公共权限成员到子类中 依然是公共权限m_B = 20;//父类中的保护权限成员到子类中 依然是保护权限//m_C = 30;//父类中的私有权限成员到子类中 访问不到}
};void test01()
{son1 s1;s1.m_A = 10;//s1.m_B = 20;//son1中m_B是保护权限 类外访问不到
}class son2 :protected dad
{
public:void func(){m_A = 10;//父类中的公共权限成员到子类中 变为保护权限m_B = 20;//父类中的保护权限成员到子类中 依然是保护权限//m_C = 30;//父类中的私有权限成员到子类中 访问不到}
};void test02()
{son2 s2;//s2.m_A = 10;//son2中m_A变为保护权限 类外访问不到//s2.m_B = 20;//son2中m_B是保护权限 不可访问
}class son3 :private dad
{
public:void func(){m_A = 10;//父类中的公共权限成员到子类中 变为私有权限m_B = 20;//父类中的保护权限成员到子类中 变为私有权限//m_C = 30;//父类中的私有权限成员到子类中 访问不到}
};void test03()
{son3 s3;//s3.m_A = 10;//son3中m_A变为私有权限 类外访问不到//s3.m_B = 20;//son3中m_B是私有权限 类外访问不到
}class grandson3 :public son3
{
public:void func(){//m_A = 10;//到son3中m_A变为私有，即使是儿子也访问不到//m_B = 20;//到son3中m_B变为私有，即使是儿子也访问不到}
};int main()
{test01();test02();test02();system("pause");return 0;
}

继承中的对象模型

#include<iostream>
using namespace std;class dad
{
public:int m_A;
protected:int m_B;
private:int m_C;
};class son :public dad
{
public:int m_D;
};void test01()
{//父类中所有非静态成员属性都会被子类继承下去//父类中私有成员属性是被编译器给隐蔽了，因此是访问不到，但是确实被继承下去了cout << "size of son=" << sizeof(son) << endl;//16
}int main()
{test01();system("pause");return 0;
}输出：
size of son=16

继承中的构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数。

#include<iostream>
using namespace std;class dad
{
public:dad(){cout << "dad构造函数" << endl;}~dad() {cout << "dad析构函数" << endl;}
};class son :public dad
{
public:son() {cout << "son构造函数" << endl;}~son(){cout << "son析构函数" << endl;}
};void test01()
{dad d;
}void test02()
{cout << "继承中的构造和析构顺序如下：" << endl;//先构造父类，再构造子类，析构的顺序与构造顺序相反son s;
}int main()
{test01();test02();system("pause");return 0;
}输出：
dad构造函数
dad析构函数
继承中的构造和析构顺序如下：
dad构造函数
son构造函数
son析构函数
dad析构函数

总结：
继承中，先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。

继承同名成员处理方式

访问子类同名成员，直接访问即可；
访问父类同名成员，需要加作用域。

#include<iostream>
using namespace std;class dad
{
public:dad(){m_A = 100;}void func(){cout << "dad的func()调用" << endl;}void func(int a){cout << "dad的func(int a)调用" << endl;}int m_A;
};class son :public dad
{
public:son(){m_A = 200;}void func(){cout << "son的func()调用" << endl;}int m_A;
};//同名成员属性处理
void test01()
{son s;cout << "son下m_A = " << s.m_A << endl;//如果通过子类对象访问到父类中同名成员，需要加作用域cout << "dad下m_A = " << s.dad::m_A << endl;
}//同名成员函数处理
void test02()
{son s;s.func();//直接调用，调用的是子类中的同名成员s.dad::func();//调用到父类中的同名成员函数//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数//如果想访问到父类中被隐藏的同名成员函数，需要加作用域s.dad::func(100);
}int main()
{test01();test02();system("pause");return 0;
}输出：
son下m_A = 200
dad下m_A = 100
son的func()调用
dad的func()调用
dad的func(int a)调用

总结：
1、子类对象可以直接访问子类中同名成员；
2、子类对象加作用域可以访问到父类同名成员；
3、当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。

继承同名静态成员处理方式

静态成员特点：
1、所有变量共享同一份数据；
2、编译阶段分配内存；
3、类内声明，类外初始化。

静态成员和非静态成员出现同名，处理方式一致：
访问子类同名成员，直接访问即可；
访问父类同名成员，需要加作用域。

#include<iostream>
using namespace std;class dad
{
public:static void func(){cout << "dad的static void func()调用" << endl;}static void func(int a){cout << "dad的static void func(int a)调用" << endl;}static int m_A;
};
int son::m_A = 100;class son :public dad
{
public:static void func(){cout << "son的static void func()调用" << endl;}static int m_A;
};
int son::m_A = 200;//同名成员属性处理
void test01()
{//通过对象访问cout << "通过对象访问：" << endl;son s;cout << "son下m_A = " << s.m_A << endl;//如果通过子类对象访问到父类中同名成员，需要加作用域cout << "dad下m_A = " << s.dad::m_A << endl;//通过类名访问cout << "通过类名访问：" << endl;cout << "son下m_A = " << son::m_A << endl;//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下cout << "dad下m_A = " << son::dad::m_A << endl;
}//同名成员函数处理
void test02()
{//通过对象访问cout << "通过对象访问：" << endl;son s;s.func();//直接调用，调用的是子类中的同名成员s.dad::func();//调用到父类中的同名成员函数//通过类名访问cout << "通过类名访问：" << endl;son::func();son::dad::func();//如果子类中出现和父类同名的静态成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数//如果想访问到父类中被隐藏的同名成员函数，需要加作用域son::dad::func(100);
}int main()
{test01();test02();system("pause");return 0;
}

总结：
同名静态成员处理方式和非静态处理方式一样，只不过有两种访问方式（通过对象和通过类名）。

多继承语法

c++允许一个类继承多个类

语法：class 子类 : 继承方式 父类1, 继承方式 父类2…

多继承可能会引发父类中有同名成员出现，需要加作用域区分

#include<iostream>
using namespace std;class dad1
{
public:dad1(){m_A = 100;}int m_A;
};class dad2
{
public:dad2(){m_A = 200;}int m_A;
};class son :public dad1, public dad2
{
public:son(){m_C = 300;m_D = 400;}int m_C;int m_D;
};void test01()
{son s;cout << "sizeof son = " << sizeof(s) << endl;//当父类在中出现同名成员，需要加作用域区分cout << "dad1::m_A = " << s.dad1::m_A << endl;cout << "dad2::m_A = " << s.dad2::m_A << endl;
}int main()
{test01();system("pause");return 0;
}

菱形继承

概念：
两个派生类继承同一个基类，又有某个类同时继承这两个派生类。
这种继承称为菱形继承，或者砖石继承。

菱形继承问题：
1、产生二义性；
2、继承两份数据，资源浪费。

利用虚继承（加关键字virtual）可以解决菱形继承问题。

#include<iostream>
using namespace std;class animal
{
public:int m_age;
};//利用虚继承 解决菱形继承的问题
//继承之前 加上关键字virtual变为虚继承
//animal类称为虚基类
class sheep :virtual public animal{};class tuo :virtual public animal{};class sheeptuo :public sheep, public tuo{};void test01()
{sheeptuo st;st.sheep::m_age = 18;st.tuo::m_age = 28;//当菱形继承，两个父类拥有相同数就，需要加上作用域区分cout << "st.sheep::m_age = " << st.sheep::m_age << endl;cout << "st.tuo::m_age = " << st.tuo::m_age << endl;cout << "st.m_age = " << st.m_age << endl;//这份数据我们知道，只有一份就可以，菱形继承导致数据有两份，造成资源浪费
}int main()
{test01();system("pause");return 0;
}

---