开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 开发工具 -> Visual Studio2017C++学习笔记（十七）-类和对象的继承 -> 正文阅读

[开发工具]Visual Studio2017C++学习笔记（十七）-类和对象的继承

前言

软件为visual studio2017，内容为C++学习笔记，以及相关的问题处理方法，目的是方便回顾和复习。
笔记来自于：黑马程序员C++教程。

一、继承是什么？

继承是面向对象三大特性之一。
类与类之间存在存在特殊的关系，在定义一些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。
因此，可以利用集成的技术，减少重复代码。

二、继承的基本语法

通过继承节约了代码量。

1.代码案例


# include <iostream>
using namespace std;
# include <string>

//继承

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

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

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 << "C++学科" << 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() {
	cout<<"Java下载的视频页面如下："<<endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "Python下载的视频页面如下：" << endl;
	cout<<"_________________________________" <<endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "C++下载的视频页面如下：" << endl;
	cout << "_________________________________" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}
int main() {
	test01();
	system("pause");
	return 0;
}

2.继承的语法

继承的好处：减少重复代码。
语法：class 子类：继承方式父类
子类 也称为派生类
父类 也称为 基类
class A：public B;
A类被称为子类 或者 派生类
B类被称为父类 或者 基类

3.派生类（子类）中的成员特点

一类是从基类中继承过来的，一类是自己增加的成员。
从基类中继承过来的表现为共性，而新增成员体现了其个性。

三、继承方式

1、继承的语法：

class 子类：继承方式父类
class 派生类：继承方式父类

2.继承方式一共有三种：

公共继承
保护继承
私有继承

3.代码示例

# include <iostream>
using namespace std;
# include <string>

//新建父类
class Base1 {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class son1 :public Base1 
{
public:
	void func() {
		m_A = 10;//公有继承中，父类中的公共权限成员，到子类中依然是公共成员。
		m_B = 20;//公有继承中，父类中的保护权限成员，到子类中依然是保护成员。
		//m_C = 30; //公有继承中，父类中的私有权限成员，到子类中不可访问。
	};
};
void test01() {
	son1 s;
	s.m_A = 20;
	//s.m_B = 30;//保护成员，类内可以访问，类外不能访问。
	//s.m_C = 30;//私有成员不能访问。
};

//新建父类
class Base2 {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//保护继承
class son2 :protected Base2 {
public:
	void func() {
		m_A = 10; //保护继承中，父类中的公共权限成员，到子类中变为保护权限。
		m_B = 20;//保护继承中，父类中的保护权限成员，到子类中依然是保护成员。
		//m_C = 30;//保护继承中，父类中的公共权限成员，到子类中依然是公共成员。
	};
};
void test02() {
	son2 s;
	//s.m_A = 20;//son2中的m_A变为保护权限，类内可以访问，类外不能访问。
	//s.m_B = 30;//保护成员，类内可以访问，类外不能访问。
	//s.m_C = 30;//私有成员不能访问。
};

//私有继承
//新建父类
class Base3 {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class son3 :private Base3 {
public:
	void func() {
		m_A = 10;//父类中公共成员 到子类中变为 私有成员
		m_B = 20;//父类中保护成员 到子类中变为 私有成员
		//m_C = 30;//父类中的私有成员，子类访问不到。

	};
};
void test03() {
	son3 s;
	//s.m_A = 100;//到了son3中变为了私有成员，类外访问不到。
	//s.m_B = 20;
	//s.m_C = 30;
}
class GrandSon3 :public son3 {
public:
	void func() {
		//m_A = 1000;//由于son3中的m_A已经是私有成员，继承后也仍是私有成员，不可访问。
		//m_B = 1000;//由于son3中的m_B已经是私有成员，继承后也仍是私有成员，不可访问。
	}

};
int main() {
	system("pause");
	return 0;
}

四、继承中的对象模型

从父类中继承过来的成员，哪些属于子类对象中？

1.代码示例

# include <iostream>
using namespace std;
# include <string>


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

//公共继承
class Son :public Base {
public:
	//子类继承了父类的m_A,m_B,m_C三个属性，加上m_D一个属性，一共四个属性。
	int m_D;
};

//利用开发人员命令提示工具查看对象模型
//跳转盘符 F:
//跳转文件路径 cd 具体路径下
//查看命名
//cl /d1 reportSingleClassLayout类名 "文件名.cpp "

void test01() 
{
	//测试子类对象的大小
	//16
	//父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器给隐藏了，因此是访问不到的，但是确实是被继承下去了
	cout << "sizeof(son)的大小为：" << sizeof(Son) << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

2.使用开发者命令提示符号

打开visualStudio2017下的开发者命令提示符号。
将XX.cpp文件，右键-打开文件所在文件夹，并复制路径。例如：F:…\继承方式
（使用英文）进入到F盘中 —— F:。
F: cd F:…\继承方式（文件路径）
dir——查看当前文件包含内容。
报告单个类的布局：cl /d1 reportSingleClassLayout类名 “文件名…cpp”

3.结论

父类中的私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到。

五、继承中构造和析构顺序

1.构造顺序

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

2.析构顺序

先创建父类对象，然后创建子类对象。
先析构子类对象，然后再析构父类对象。

3.代码示例

在这里插入图片描述

4.总结

继承中构造和析构顺序如下：
先构造父类先调用父类函数，再构造子类调用子类的构造函数，析构的顺序和构造的顺序相反。
继承的时候，构造和析构顺序原理类似于压栈和退栈。

六、继承同名成员处理方式

1、问题

问题：当子类和父类出现同名成员时，如何通过子类访问到子类和父类中的同名的数据那？
访问子类同名成员时，直接访问即可。
访问父类同名成员时，需加作用域。

2.代码示例

# include <iostream>
using namespace std;
# include <string>

//创建父类
class Base {
public:
	Base() {
		m_A = 100;
	};
	void func() {
		cout << "父类Base - func()调用。" <<endl;
	};
	void func(int a) {
		cout<<"父类中的Base-func(int a)的重载"<<endl;
	}
	int m_A;
};
class Son :public Base {
public:
	Son() {
		m_A = 200;
	}
	void func() {
		cout << "子类中的func()函数调用" << endl;
	}
	int m_A;
};

//同名的成员属性处理方式
void test01() {
	Son s1;
	cout << "子类中的m_A = " << s1.m_A << endl;
	//如果通过子类对象 访问父类中的同名成员，需要加作用域
	cout << "父类中的m_A = " << s1.Base::m_A << endl;
};
//同名的成员函数的处理方式
void test02() {
	Son s2;
	s2.func();
	//当子类中没有func函数，子类会调用继承父类中的func（）函数
	//直接调用s2.func()，调用的是自身的func（）函数
	//当子类中也有func函数，子类对象要调用父类的func（）函数，需要指明作用域。
	s2.Base::func();
	//当子类中没有重名函数func（）时候，func(int a)函数重载可以调用。
	//当子类中含有同名函数时候，父类中重载函数不能调用。
	//原理：如果子类中出现了和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名成员函数（包括重载函数）
	//如果想访问父类中的被隐藏的同名成员函数，需要加作用域。
	s2.Base::func(20);
	//总结：子类中如果没有同名成员，则可以访问父类中的成员。
	//子类中如果有同名成员，访问父类中的成员需要加作用域。
};
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

3.小结

子类对象可以直接访问到子类中的同名成员。
子类对象加上作用域可以访问父类中的同名成员。
当子类与父类拥有同名的成员函数，子类会隐藏掉父类中所有同名成员函数，加作用域可以访问到父类中同名函数。

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

1.问题

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

2.解决方法

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

3.静态成员变量特点

所有成员共享一份数据
编译阶段就开始分配内存。
类内声明，类外初始化。

4.静态的成员函数特点

静态的成员函数只能访问静态成员变量，不能访问非静态的成员变量。
所有对象共享同一份函数实例

5.代码示例

# include <iostream>
using namespace std;
# include <string>

//继承中的同名静态成员的处理方式
class Base {
public:
	//静态变量，类内声明，类外初始化
	static int m_A;
	static void func()
	{
		cout << "Base-static void func()函数" << endl;
	};
	static void func(int a) 
	{
		cout << "Base-static void func(int a)函数" << endl;
	}
};
//数据类型 类名::静态变量名 = 值；
int Base::m_A = 100;//

class Son :public Base {
public:
	//静态变量，类内声明，类外初始化。
	static int m_A;
	static void func() 
	{
		cout << "Son-static void func()函数" << endl;
	}
};
//数据类型 类名::静态变量 = 值;
int Son::m_A = 200;

//1、同名的静态成员属性
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::m_A表示Base作用域下的m_A属性
}

//2、同名的静态成员函数
void test02() {
	//通过对象访问；
	cout <<"通过对象进行访问"<<endl;
	Son s;
	//s.func(20);//不能访问，由于子类对象已将父类同名函数隐藏。
	//子类出现和父类同名的静态成员函数，也会隐藏父类中所有同名的成员函数
	//如果想访问父类中被隐藏的同名成员，需要加作用域。
	s.Base::func(20);
	s.Base::func();

	//通过类名访问
	cout << "通过类名访问" << endl;
	Son::func();
	Son::Base::func();
	//其中Son::表示通过类名访问，Base::表示作用域。
	
};
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

6.小结

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

八、多继承语法

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

1.代码示例

# include <iostream>
using namespace std;
# include <string>

//多继承语法
class Base1 {
public:
	Base1() {
		m_A = 10;
		m_B = 10;
	};
	int m_A;
	int m_B;
};
class Base2 {
public:
	Base2()
	{
		m_B = 20;
		m_A = 20;
	}
	int m_B;
	int m_A;
};
//子类需要继承父类Base1 父类Base2。
//语法：class 子类：public 父类1，public 父类2
class Son :public Base1, public Base2 {
public:
	Son() {
		m_C = 300;
		m_D = 400;
	};
	int m_C;
	int m_D;
};

void test02() {
	Son s;
	cout<<"sizeof Son  = "<<sizeof(Son)<<endl;
	//当父类中出现同名成员，需要加作用域区分
	cout<<"Base1中的m_A = "<<s.Base1::m_A<<endl;
	cout <<"Base2中的m_A = "<<s.Base2::m_A<<endl;
}

int main() {
	test02();
	system("pause");
	return 0;
}

九、棱形继承的问题以及解决办法

1.棱形继承的概念

两个派生类继承同一个基类
又有某个类同时继承两个派生类
这种继承被称为棱形继承，者是钻石继承

在这里插入图片描述

棱形继承的问题
1、羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
2、草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以，棱形继承导致数据有两份资源浪费。

2.代码示例

# include <iostream>
using namespace std;
#include <string>
//动物类
class Animal {
public:
	int m_Age;
};
//羊类
class Sheep:public Animal {

};
//驼类
class Tuo :public Animal {};

//草泥马类
class SheepTuo :public Sheep, public Tuo {

};
void test01() {
	SheepTuo st;
	//st.m_Age = 100;//多继承问题，值不明确，定义时需要加作用域
	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;


};
int main() {
	test01();
	system("pause");
	return 0;
};

3.棱形问题解决办法

利用虚继承解决棱形继承的问题。

# include <iostream>
using namespace std;
#include <string>
//动物类
class Animal {
public:
	int m_Age;
};

//利用虚继承解决棱形继承的问题

//继承之前 加上关键字 virtual 变为虚继承
//class 子类：virtual 继承方式 父类
//Animal称为虚基类。
//羊类
class Sheep:virtual public Animal {

};
//驼类
class Tuo :virtual public Animal {};

//草泥马类
class SheepTuo :public Sheep, public Tuo {

};
void test01() {
	SheepTuo st;
	//st.m_Age = 100;//多继承问题，值不明确，定义时需要加作用域
	st.Sheep::m_Age = 200;
	st.Tuo::m_Age = 100;
	//虚继承后，数据变为一份，以最后的修改值为准。
	//当棱形继承，两个父类拥有相同数据，需要加以作用域区分。
	cout << "st.Sheep::m_Age" << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age" <<st.Tuo::m_Age << endl;
	cout << st.m_Age << endl;
	//此时，m_Age只有一份数据。

};
int main() {
	test01();
	system("pause");
	return 0;
};