【C++】C++核心编程（九）---类与对象（继承）

DU-KE

已于 2023-03-27 16:45:01 修改

阅读量383

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-03-26 10:25:40 首次发布

本文链接：https://blog.csdn.net/qq_43723025/article/details/129584717

版权

C++ 专栏收录该内容

21 篇文章 4 订阅

订阅专栏

1.继承的基本语法

继承是面向对象三大特性之一
有些类与类之间存在特殊的关系，如下图所示：
在这里插入图片描述
我们可以发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性，这个时候我们就可以考虑利用继承的技术，减少重复代码。
继承的基本语法：class 子类(派生类) : 继承方式(Public or Protect or Private) 父类(基类)

代码演示

案例描述：我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同，接下来请分别利用普通写法和继承的写法来实现网页中的内容

普通写法来实现

#include <iostream>
using namespace std;

//1、普通实现网页中的内容
class Java
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...（公共分类列表）" << endl;
	}
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};

class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++...（公共分类列表）" << endl;
	}
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};

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()
{
	Java java;
	java.header();
	java.footer();
	java.left();
	java.content();
}

void test02()
{
	Python python;
	python.header();
	python.footer();
	python.left();
	python.content();
}

void test03()
{
	Cpp cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}

int main() {
	cout << "Java视频下载页面如下：" << endl;
  test01();
	cout << "---------------------------------------------" << endl;
  cout << "Python视频下载页面如下：" << endl;
	test02();
	cout << "---------------------------------------------" << endl;
  cout << "C++视频下载页面如下：" << endl;
	test03();

	system("pause");
	return 0;
}

输出结果：

Java视频下载页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...（公共底部）
Java、Python、C++...（公共分类列表）
Java学科视频
---------------------------------------------
Python视频下载页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...（公共底部）
Java、Python、C++...（公共分类列表）
Python学科视频
---------------------------------------------
C++视频下载页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...（公共底部）
Java、Python、C++...（公共分类列表）
C++学科视频
请按任意键继续. . .

继承写法来实现

#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 test01()
{
	Java java;
	java.header();
	java.footer();
	java.left();
	java.content();
}

void test02()
{
	Python python;
	python.header();
	python.footer();
	python.left();
	python.content();
}

void test03()
{
	Cpp cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}

int main() {
	cout << "Java视频下载页面如下：" << endl;
	test01();
	cout << "---------------------------------------------" << endl;
	cout << "Python视频下载页面如下：" << endl;
	test02();
	cout << "---------------------------------------------" << endl;
	cout << "C++视频下载页面如下：" << endl;
	test03();

	system("pause");
	return 0;
}

输出结果：

Java视频下载页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...（公共底部）
Java、Python、C++...（公共分类列表）
Java学科视频
---------------------------------------------
Python视频下载页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...（公共底部）
Java、Python、C++...（公共分类列表）
Python学科视频
---------------------------------------------
C++视频下载页面如下：
首页、公开课、登录、注册...（公共头部）
帮助中心、交流合作、站内地图...（公共底部）
Java、Python、C++...（公共分类列表）
C++学科视频
请按任意键继续. . .

2.继承方式

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

继承方式有三种：

公共继承Public（父类中的私有权限在子类中不可访问，公共权限和保护权限不变）
保护继承protected（父类中的私有权限在子类中不可访问，公共权限和保护权限都变为保护权限）
私有继承private（父类中的私有权限在子类中不可访问，公共权限和保护权限都变为私有权限）

通过画图的方式理解
在这里插入图片描述

代码演示：

#include <iostream>
using namespace std;

class Basis
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son1 : public Basis
{
public:
	void func1()
	{
		m_A = 100; //父类中的公共权限成员，到子类中依然是公共权限
		m_B = 200; //父类中的保护权限成员，到子类中依然是保护权限
		//m_C = 300; //父类中的私有权限成员，子类访问不到
	}
};

class Son2 : protected Basis
{
public:
	void func2()
	{
		m_A = 200; //父类中的公共权限成员，到子类中变为保护权限
		m_B = 400; //父类中的保护权限成员，到子类中依然为保护权限
		//m_C = 600; //父类中的私有权限成员，子类访问不到
	}
};

class Son3 : private Basis
{
public:
	void func3()
	{
		m_A = 300; //父类中的公共权限成员，到子类中变为私有权限
		m_B = 600; //父类中的保护权限成员，到子类中变为私有权限
		//m_C = 900; //父类中的私有权限成员，子类访问不到
	}
};

class GrandSon3 : public Son3
{
public:
	void func4()
	{
		//m_A = 330; //到了Son3中，m_A变为私有，即使是儿子，也是访问不到的
		//m_B = 340; //到了Son3中，m_B变为私有，即使是儿子，也是访问不到的
	}
};

void test01()
{
	Son1 s1;
	s1.func1();
	cout << s1.m_A << endl;
	//cout << s1.m_B << endl; //到子类中，m_B是保护权限，类外访问不到
}

void test02()
{
	Son2 s2;
	s2.func2();
	//cout << s2.m_A << endl; //到子类中，m_A是保护权限，类外访问不到
	//cout << s2.m_B << endl; //到子类中，m_B是保护权限，类外访问不到
}

void test03()
{
	Son3 s3;
	s3.func3();
	//cout << s3.m_A << endl; //到子类中，m_A是私有权限，类外访问不到
	//cout << s3.m_A << endl; //到子类中，m_B是私有权限，类外访问不到
}

int main() {
	test01();
	test02();
	test03();

	system("pause");
	return 0;
}

输出结果：

100
请按任意键继续. . .

3.继承中的对象模型

问题：从父类继承过来的成员，哪些是属于子类对象上的？？？

继承父类以后，在父类对象上的成员都会在子类的对象上，不管是采用的哪一种继承方式。

代码演示

#include <iostream>
using namespace std;

class Basis
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};

class Son : public Basis
{
public:
	int m_D;
};

void test()
{
	cout << "sizeof(Son) = " << sizeof(Son) << endl;
}

int main() {
	test();

	system("pause");
	return 0;
}

输出结果

sizeof(Son) = 16
请按任意键继续. . .

利用开发人员命令提示工具查看对象模型：
1、跳转盘符 D：
2、跳转文件路径 cd 具体路径下
3、查看命名dir
4、cl /d1 reportSingleClassLayout类名文件名

可以看到在子类Son对象上的成员
通过下图也可以看到基类Basis对象上的成员

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

子类继承父类后，当创建子类对象，也会调用父类的构造和析构函数。那么父类和子类的构造和析构顺序是谁先谁后？？？

继承中的构造和析构顺序是：先构造父类，再构造子类，析构的顺序与构造的顺序相反。
当类A对象作为类B的成员时，类A与类B的构造与析构顺序是谁先谁后？？？
见文章对象的初始化与清理类对象作为类成员。构造顺序：先A后B；析构顺序：先B后A。

代码演示

#include <iostream>
using namespace std;

class Basis
{
public:
	Basis()
	{
		cout << "Basis 构造函数的调用" << endl;
	}

	~Basis()
	{
		cout << "Basis 析构函数的调用" << endl;
	}
};

class Son : public Basis
{
public:
	Son()
	{
		cout << "Son 构造函数的调用" << endl;
	}

	~Son()
	{
		cout << "Son 析构函数的调用" << endl;
	}
};

void test()
{
	//继承中的构造和析构顺序如下:
	//先构造父类，再构造子类，析构的顺序与构造的顺序相反
	Son s;
	cout << sizeof(s) << endl;
}

int main() {
	test();

	system("pause");
	return 0;
}

输出结果

Basis 构造函数的调用
Son 构造函数的调用
1
Son 析构函数的调用
Basis 析构函数的调用
请按任意键继续. . .

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

当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

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

代码演示

同名成员变量的访问

#include <iostream>
using namespace std;

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

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

void test()
{
	Son s;
	// 同名成员变量的处理
	cout << "Son下 s.m_A = " << s.m_A << endl; //子类访问同名的自己的成员变量只需要直接访问

	cout << "Basis下 s.m_A = " << s.Basis::m_A << endl; //子类访问同名的父类的成员变量需要加上作用域
}

int main() {
	test();

	system("pause");
	return 0;
}

输出结果

Son下 s.m_A = 200
Basis下 s.m_A = 100
请按任意键继续. . .

同名成员函数的访问

#include <iostream>
using namespace std;

class Basis
{
public:
	Basis()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Basis - func()的调用" << endl;
	}
	void func(int a)
	{
		cout << "Basis - func(int a)的调用" << endl;
	}
	int m_A;
};

class Son : public Basis
{
public:
	Son()
	{
		m_A = 200;
	}
	void func()
	{
		cout << "Son - func()的调用" << endl;
	}
	int m_A;
};

void test()
{
	Son s;
	// 同名成员函数的处理
	s.func(); //子类中的同名函数 直接调用即可

	s.Basis::func(); //父类中的同名函数 其调用需要加上作用域

	s.Basis::func(100); //如果子类中出现和父类同名的成员函数，子类的同名函数会隐藏掉父类中所有的同名成员函数
					    //如果想访问到父类中被隐藏的同名成员函数，需要加作用域
}

int main() {
	test();

	system("pause");
	return 0;
}

输出结果

Son - func()的调用
Basis - func()的调用
Basis - func(int a)的调用
请按任意键继续. . .

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

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

继承中同名静态成员在子类对象上如何进行访问？？？

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

代码演示

#include <iostream>
using namespace std;

class Basis 
{
public:
	static void func()
	{
		cout << "Basis - static void func()的调用" << endl;
	}
	static void func(int a)
	{
		cout << "Basis - static void func(int a)的调用" << endl;
	}

	static int m_A;
};
int Basis::m_A = 100;

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

	static int m_A;
};
int Son::m_A = 200;

void test()
{
	Son s;
	//静态成员变量的处理
	//1、通过对象的方式访问
	cout << "通过对象的方式访问" << endl;
	cout << "Son下静态成员变量 s.m_A = " << s.m_A << endl;

	cout << "Basis下静态成员变量 s.m_A = " << s.Basis::m_A<< endl;
	//2、通过类名的方式访问
	cout << "通过类名的方式访问" << endl;
	cout << "Son下静态成员变量 s.m_A" << Son::m_A << endl;
	//第一个::代表通过类名的方式访问   第二个::代表访问父类作用域下的
	cout << "Basis下静态成员变量 s.m_A" << Son::Basis::m_A << endl;
	
	//静态成员函数的处理
	cout << "\n\n\n" << endl;
	cout << "通过对象的方式访问" << endl;
	s.func();
	s.Basis::func();
	s.Basis::func(100);

	cout << "通过类名的方式访问" << endl;
	Son::func();
	Son::Basis::func();
	Son::Basis::func(100);
}

int main() {
	test();

	system("pause");
	return 0;
}

输出结果

通过对象的方式访问
Son下静态成员变量 s.m_A = 200
Basis下静态成员变量 s.m_A = 100
通过类名的方式访问
Son下静态成员变量 s.m_A200
Basis下静态成员变量 s.m_A100




通过对象的方式访问
Son - static void func()的调用
Basis - static void func()的调用
Basis - static void func(int a)的调用
通过类名的方式访问
Son - static void func()的调用
Basis - static void func()的调用
Basis - static void func(int a)的调用
请按任意键继续. . .

总结：
同名静态成员处理方式与非静态成员处理方式一样，只不过有两种访问的方式（通过对象和通过类名）。静态成员有两种访问方式的原因是它们被所有类对象共用，因此可以通过类名来进行访问。

7.多继承语法

C++允许一个类继承多个类
语法：
class 子类：继承方式父类1，继承方式父类2…
缺点：
多继承可能会引发父类中有同名成员出现，需要加作用域进行区分。在C++实际开发中不建议用多继承

代码演示

#include <iostream>
using namespace std;

class Basis1
{
public:
	Basis1()
	{
		m_A = 100;
		m_B = 200;
	}
	int m_A;
	int m_B;
};

class Basis2
{
public:
	Basis2()
	{
		m_A = 300;
		m_C = 400;
	}
	int m_A;
	int m_C;
};

class Son : public Basis1, public Basis2
{
public:
	Son()
	{
		m_D = 500;
	}
	int m_D;
};

void test()
{
	Son s;
	cout << "类Son的对象s所占用的内存大小sizeof(s) = " << sizeof(s) << endl;
	//当一个类继承几个父类的时候并且父类中有同名成员时，子类对象访问父类成员会报错【不明确】
	//此时需要加上作用域来进行一个区分
	cout << "Basis1中的属性m_A = " << s.Basis1::m_A << endl;
	cout << "Basis2中的属性m_A = " << s.Basis2::m_A << endl;
	cout << "Basis1中的属性m_B = " << s.m_B << endl;
	cout << "Basis2中的属性m_C = " << s.m_C << endl;
	cout << "Son中的属性m_D = " << s.m_D << endl;
}

int main() {
	test();

	system("pause");
	return 0;
}

输出结果

类Son的对象s所占用的内存大小sizeof(s) = 20
Basis1中的属性m_A = 100
Basis2中的属性m_A = 300
Basis1中的属性m_B = 200
Basis2中的属性m_C = 400
Son中的属性m_D = 500
请按任意键继续. . .

通过下图（利用开发者命令行工具得到）可以看到类Son对象上的成员有哪些，一部分是从父类Basis1继承来的，另一部分是从父类Basis2上继承来的，还有一部分是自己类上的。
在这里插入图片描述

8.菱形继承

概念：
两个派生类继承同一个基类，又有某个类同时继承这两个派生类，这种继承被称为菱形继承，或钻石继承。
菱形继承案例：
基类：动物
两个派生类：羊、驼
再一个派生类：羊驼(草泥马)
在这里插入图片描述
菱形继承存在的问题：
1、羊和驼继承了动物的数据，当草泥马使用数据时，就会产生二义性
2、草泥马继承自动物的数据继承了两份，我们实际是只需要一份这个数据就可以了

问题解决方法：
1、针对二义性的问题，可以通过加作用域的方式来解决；
2、针对会继承两份数据的问题，可以利用虚继承来解决。虚继承会让数据只继承一份，此时问题一也得到了解决，利用虚继承就可以直接解决菱形继承所有的问题。

虚继承的实现：
在继承之前加上关键字virtual就可以了，class 派生类：virtual 继承方式基类
注意：
1、当使用虚继承以后，继承过来数据只有一份，此时也就不会产生二义性，也就不需要加作用域来调用成员变量了。
2、使用虚继承与不使用虚继承子类对象所占用的内存是不一样的。
（1）不使用虚继承时：sizeof(st)=8；不使用虚继承：两个派生类中继承了基类的数据m_A，而子类又要继承两个不同派生类中的数据m_A，因此是占用8个字节（两份数据）
（2）使用虚继承：sizeof(st)=12；虚继承：创建了两个虚基类指针指向相同的数据m_A，而子类继承了数据m_A，因此是占用12个字节（一份数据，两个虚基类指针）

vbptr = virtual + base + pointer（是一个虚基类指针，指向虚基类表）
vbtable = virtual + base + table（是一个虚基类表）

代码演示

#include <iostream>
using namespace std;

class Animal
{
public:
	Animal()
	{
		m_A = 100;
	}
	int m_A;
}
// Animal类称为 虚基类
class Sheep:virtual public Animal{};

class Tuo :virtual public Animal {};

class SheepTuo :public Sheep, public Tuo {};

void test()
{
	SheepTuo st;

	//cout << "sizeof(st) = " << sizeof(st) << endl; //sizeof(st) = 8 未使用虚继承时
	cout << "virtual sizeof(st) = " << sizeof(st) << endl; //sizeof(st) = 12 使用虚继承时
	//使用虚继承和不使用虚继承 子类对象所占用的内存不一样的原因是：
	//虚继承：创建了两个虚基类指针指向相同的数据m_A，而子类继承了数据m_A，因此是占用12个字节
	//不使用虚继承：两个派生类中继承了基类的数据m_A，而子类又要继承两个不同派生类中的数据m_A，因此是占用8个字节

	st.Sheep::m_A = 18;
	st.Tuo::m_A = 24;
	// 当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	cout << "st.Sheep::m_A = " << st.Sheep::m_A << endl;
	cout << "st.Tuo::m_A = " << st.Tuo::m_A << endl;
	cout << "st.m_A = " << st.m_A << endl;
}

int main() {

	test();

	system("pause");
	return 0;
}

输出结果

virtual sizeof(st) = 12
st.Sheep::m_A = 24
st.Tuo::m_A = 24
st.m_A = 24
请按任意键继续. . .

总结：
1、菱形继承带来的主要问题是子类继承两份数据相同的数据，导致资源浪费以及毫无意义
2、利用虚继承可以解决菱形继承的问题