本文主要是介绍C++核心编程——4.6 继承，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
继承是面向对象三大特性之一
4.6.1 继承的概念和作用
定义：
继承(inheritance)机制允许在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）。
作用：可以减少重复的代码
语法：
class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类
注： 派生类中的成员，包含两大部分：
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性。
//公共属性
class Base
{
public:void header(){cout << "公共属性的内容" << endl;}};//特有属性1:test1
class test1 : public Base
{
public:void content(){cout << "特有属性1:test1" << endl;}
};//特有属性2:test2
class test2 : public Base
{
public:void content(){cout << "特有属性2:test2" << endl;}
};void test01()
{//特有属性1cout << "特有属性1页面如下： " << endl;test1 t1;t1.header();t1.content();cout << "--------------------" << endl;//特有属性2cout << "特有属性2页面如下： " << endl;test2 t2;t2.header();t2.content();cout << "--------------------" << endl;}int main() {test01();system("pause");return 0;
}4.6.2 继承的方式
| 父类——class A | |||
| 继承方式 语法：class 子类:public 父类 | public 类内/外可访问 | protected 只类内可访问 | private |
| 公共继承 语法：class B:public A | public | protected | 不可访问 |
| 保护继承 语法：class B:protected A | protected | ||
| 私有继承 语法：class B:private A | private | ||
| 嵌套继承 | 原来的子类（现在的父类）继承的对象按如上的规则作为自己的访问权限被另一个子类继承 | ||
class father
{
public:int m_a;
protected:int m_b;
private:int m_c;
};class son1 : public father
{void function(){m_a = 10;m_b = 10; //父类中的公共属性和保护属性类内可以访问//m_c = 10; //父类中的私有属性类内不可访问}
};class son2 : protected father
{void function(){m_a = 10;m_b = 10; //父类中的公共属性和保护属性类内可以访问//m_c = 10; //父类中的私有属性类内不可访问}
};class son3 : private father
{void function(){m_a = 10;m_b = 10; //父类中的公共属性和保护属性类内可以访问//m_c = 10; //父类中的私有属性类内不可访问}
};void test01()
{son1 s1;s1.m_a = 20; //父类中的公共属性类外可以访问//s1.m_b = 20;//s1.m_c = 20; //父类中的保护属性和私有属性类外可以访问son2 s2;//s2.m_a = 20;//s2.m_b = 20;//s2.m_c = 20; //父类中的公共属性、保护属性和私有属性类外可以访问son3 s3;//s3.m_a = 20;//s3.m_b = 20;//s3.m_c = 20; //父类中的公共属性、保护属性和私有属性类外可以访问};//继承嵌套
class GrandSon : public son3 //原先的子类现在成员父类
{//m_a = 10;//m_b = 10; //m_c = 10; //三个变量都是son3采用private方式从father中继承的，已经变成son3中的private
};int main()
{test01();system("pause");return 0;
}4.6.3 继承中的对象模型
父类中的私有成员是被编译器隐藏了访问不到，但是会被继承
class Base
{
public:int m_A;
protected:int m_B;
private:int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};//公共继承
class Son :public Base
{
public:int m_D;
};void test01()
{cout << "sizeof Son = " << sizeof(Son) << endl;
}int main() {test01();system("pause");return 0;
}对用的继承对象模型如下图所示：
4.6.4 继承中构造和析构顺序
继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
class Base
{
public:Base(){cout << "Base构造函数!" << endl;}~Base(){cout << "Base析构函数!" << endl;}
};class Son : public Base
{
public:Son(){cout << "Son构造函数!" << endl;}~Son(){cout << "Son析构函数!" << endl;}};void test01()
{//继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反Son s;
}int main() {test01();system("pause");return 0;
}4.6.5 继承同名成员处理方式
| 访问子类同名成员 | 访问父类同名成员 | ||
| 成员对象 | 成员函数 | 成员对象 | 成员函数 |
| 直接访问（不用写明作用域） | 语法：s.Base::m_A 其中s为子类创建的类对象，Base为父类的类名（作用域） | 语法：s.Base::func() 其中s为子类创建的类对象，Base为父类的类名（作用域） | |
| 没有作用域访问子类，有作用域访问作用域 | |||
| 注：当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父 类中同名函数 | |||
class Base {
public:Base(){m_A = 100;}void func(){cout << "Base - func()调用" << endl;}void func(int a) //函数的重载{cout << "Base - func(int a)调用" << endl;}public:int m_A;
};class Son : public Base {
public:Son(){m_A = 200;}//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域void func(){cout << "Son - func()调用" << endl;}
public:int m_A;
};void test01()
{Son s;cout << "Son下的m_A = " << s.m_A << endl;cout << "Base下的m_A = " << s.Base::m_A << endl;s.func();s.Base::func();s.Base::func(10);//如果子类中有func()父类中有func()和func(int a)//当只是调用s.func(10);时候子类会隐藏父类中的所有同名成员函数（包括func()和func(int a)），此时会报错
}
int main() {test01();system("pause");return EXIT_SUCCESS;
}4.6.6 继承同名静态成员处理方式
静态成员和非静态成员出现同名，处理方式一致，只不过有两种访问的方式（通过对象 和 通过类名）
class Base {
public:static void func(){cout << "Base - static void func()" << endl;}static void func(int a){cout << "Base - static void func(int a)" << endl;}static int m_A;
};int Base::m_A = 100;class Son : public Base {
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 << "Base 下 m_A = " << s.Base::m_A << endl;//通过类名访问cout << "通过类名访问： " << endl;cout << "Son 下 m_A = " << Son::m_A << endl;cout << "Base 下 m_A = " << Son::Base::m_A << endl;//两个冒号含义不同，第一个表示通过类名son的方式访问数据，第二个冒号表示在Base（父类）的作用域
}//同名成员函数
void test02()
{//通过对象访问cout << "通过对象访问： " << endl;Son s;s.func();s.Base::func();cout << "通过类名访问： " << endl;Son::func();Son::Base::func();//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问Son::Base::func(100);
}
int main() {//test01();test02();system("pause");return 0;
}4.6.7 多态继承语法
作用：一个类继承多个
语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...
注：多继承中如果父类中出现了同名情况，子类使用时候要加作用域
class Base1 {
public:Base1(){m_A = 100;}
public:int m_A;
};class Base2 {
public:Base2(){m_A = 200; //开始是m_B 不会出问题，但是改为mA就会出现不明确}
public:int m_A;
};//语法：class 子类：继承方式 父类1 ，继承方式 父类2
class Son : public Base2, public Base1
{
public:Son()//构造函数{m_C = 300;m_D = 400;}
public:int m_C;int m_D;
};//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{Son s;cout << "sizeof Son = " << sizeof(s) << endl;cout << s.Base1::m_A << endl;cout << s.Base2::m_A << endl;
}int main() {test01();system("pause");return 0;
}4.6.8 菱形继承
概念：
两个派生类继承同一个基类，同时又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石继承，作用图如下图所示：
案例：
问题：
-
羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性；
-
草泥马继承自动物的数据继承了两份，而这份数据只需要一份就可以；
解决方案：
虚拟继承（解决继承两份相同数据的问题，防止资源浪费）
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 = 100;st.Tuo::m_Age = 200;
//虚继承之后相当于只有一份数据，大家共享，输出可以不用加作用域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;
}虚拟继承的底层原理如下图所示：
虚拟继承的本质是继承两个指针（vptr虚基类指针），该指针指向的是对应的类表（vbtable虚基类表），在虚基类表中记录的是对象的类中的偏移量（sheep的偏移量为8，tuo的偏移量为4，原来的地址是0，在sheep类中0（原始sheep类的位置） + 8 （偏移量） = 8 ；在tuo类中4（原始tuo类的位置） + 4 （偏移量） = 8 ，最终两者指向的是同一块为8 的地址，解决了继承两份相同数据的问题。
这篇关于C++核心编程——4.6 继承的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
