【C++核心编程】4.6类和对象：继承

一、封装

本章内容请点击跳转

二、对象的初始化和清理

本章内容请点击跳转

三、C++对象模型和this指针

本章内容请点击跳转

四、友元

本章内容请点击跳转

五、运算符重载

本章内容请点击跳转

六、继承

1. 继承的基本语法

继承的好处：减少重复代码
语法：class 子类: 继承方式 父类 {}；，其中子类也称为派生类，父类也称为基类，继承方式有公共继承、保护继承、私有继承三种。子类中的成员包含两大部分，一类是从父类继承过来的，一类是自己增加的成员；从父类继承过来的表现其共性，而新增的成员体现了其个性。

如果需要实现相同的网页头部、底部、左侧，中间的内容是不同的，那么普通实现是：

//普通实现页面

//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 test01()
{
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "---------------------" << endl;
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "---------------------" << endl;
	cout << "C++下载视频页面如下：" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}

使用继承方式的实现方法是：

//继承实现页面

//公共页面类
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;
	}
};

2. 继承方式

继承的语法：class 子类: 继承方式 父类 {}；
继承方式一共有三种：

• 公共继承public
• 保护继承protected
• 私有继承private

总结：
父类私有的属性，子类都不可以访问！
公共继承：父类中公共属性、被保护属性在子类中访问权限都不变。
保护继承：父类中公共权限、保护权限的内容在子类中均为保护权限。
私有继承：除了父类不可访问的私有权限内容，其它内容均为私有权限。
公共权限类内外均可访问；保护权限类内可以访问，类外不可以访问；私有权限类内外均不可访问。

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) << endl;//16
}

最后的结果是16（m_A、m_B、m_C、m_D），也就是说父类中所有非静态成员属性都会被子类继承下去。父类中私有成员属性是被编译器隐藏了，因此访问不到，但确实被继承下去了。

也可以使用VisualStudio自带的工具查看对象模型：开发人员命令提示符Developer Command Prompt for VS 2019，然后跳转到当前代码所在的文件夹（先跳转盘符D:，然后跳转文件路径cd xxx），输入cl /d1 reportSingleClassLayoutSon "源.cpp"，即可查看源.cpp(文件名)文件下Son（类名）类的布局，结果如下，可以清晰了解它所占的内存空间以及其父类：

4. 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数。先构造父类，然后再构造子类；析构顺序与构造的顺序相反。（后进先出）

5. 继承同名成员处理方式

当子类和父类出现同名的成员时：

• 访问子类同名成员：直接访问即可
• 访问父类同名成员：需要加作用域

① 对于同名成员属性：

class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	int m_A;
};

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	int m_A;
};

void test01()
{
	Son s;
	cout << "Son m_A = " << s.m_A << endl;//200
	cout << "Base m_A = " << s.Base::m_A << endl;//100
	//如果通过子类对象访问到父类中同名成员，需要加作用域
}

② 对于同名成员函数：

class Base
{
public:
	void func()
	{
		cout << "Base - func()调用" << endl;
	}
};

class Son :public Base
{
public:
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
};

void test01()
{
	Son s;
	s.func();//Son - func()调用
	s.Base::func();//Base - func()调用
}

如果子类中出现和父类同名的成员函数，子类的同名函数会隐藏掉父类中所有同名成员函数（包括发生函数重载的），无法通过子类对象直接访问。如果想访问到父类中被隐藏的同名成员函数，需要加作用域。

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

复习：
静态成员属性：所有对象都共享同一份数据，编译阶段就分配内存，类内声明，类内初始化
静态成员函数：只能访问静态成员属性，不能访问非静态成员变量

静态成员和非静态成员出现同名，处理方式一致：

• 访问子类同名成员：直接访问即可
• 访问父类同名成员：需要加作用域

① 同名静态成员属性：

class Base
{
public:
	static int m_A;
};
int Base::m_A = 100;

class Son :public Base
{
public:
	static int m_A;
};
int Son::m_A = 200;

void test01()
{
	//1、静态成员属性可以通过对象访问
	cout << "通过对象访问" << endl;
	Son s;
	cout << "Son m_A = " << s.m_A << endl;//200
	cout << "Base m_A = " << s.Base::m_A << endl;//100
	//2、静态成员属性可以通过类名访问（因为大家共享同一份数据）
	cout << "通过类名访问" << endl;
	cout << "Son m_A = " << Son::m_A << endl;//200
	cout << "Base m_A =" << Base::m_A << endl;//100，直接通过Base类访问
	cout << "Base m_A =" << Son::Base::m_A << endl;//100，通过Son类去访问父类作用域下的属性
}

② 同名静态成员函数：

class Base
{
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
};

class Son :public Base
{
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
};

void test01()
{
	//1、通过对象访问
	cout << "通过对象访问" << endl;
	Son s;
	s.func();//Son - static void func()
	s.Base::func();//Base - static void func()
	//2、通过类名访问大家共享同一份数据）
	cout << "通过类名访问" << endl;
	Son::func();
	Son::Base::func();
}

7. 多继承语法

C++允许一个类继承多个类
语法：class 子类 :继承方式 父类1, 继承方式 父类2 ...
多继承可能会引发父类中有同名成员出现（二义性）的问题，需要加作用域区分，实际开发中不建议使用多继承。

class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};

class Base2
{
public:
	Base2()
	{
		m_A = 200;
	}
	int m_A;
};

class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};

void test01()
{
	Son s;
	cout << sizeof(s) << endl;//16
	cout << s.Base1::m_A << endl;//100
	cout << s.Base2::m_A << endl;//200
}

8. 菱形继承

菱形继承/钻石继承：两个派生类继承同一个基类，又有某个类同时继承这两个派生类。

菱形继承问题：如上图，羊继承了动物的数据，驼同样挤成了动物的数据，当羊驼使用数据时，就会产生二义性（在多继承那里讲过，可以通过加作用域解决二义性问题）。但羊驼继承动物的数据继承了两份，这份数据其实只需要一份就可以了（可利用虚继承解决）。

虚继承：在羊、驼继承之前，加上关键字virtual，变为虚继承，此时动物类（最大的那个类）称为虚基类。

class Animal
{
public:
	int m_Age;
};
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;//28
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;//28
	cout << "st.m_Age = " << st.m_Age << endl;//28
	//此时m_Age数据只有一份了！
}

【未完待续】