C++类和对象（继承）

、南城不南 ╯

已于 2023-08-01 16:01:28 修改

阅读量625

点赞数

分类专栏： C / C++ 文章标签： c++

于 2023-06-14 09:38:20 首次发布

本文链接：https://blog.csdn.net/m0_62299908/article/details/131200708

版权

C / C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

4.6继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码。

4.6.1继承的基本语法

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

//语法：class 子类：继承方式（public）父类

//子类也称为派生类

//父类也称为基类

#include<iostream>
using namespace std;
//普通实现界面

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

//继承实现页面
//公共页面类
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）"<< endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Jave、Python、C++、...（公共分类列表）" << endl;
	}
private:
	
};
//继承的好处：减少重复的代码。
//语法：class 子类 ： 继承方式（public） 父类
//子类  也称为  派生类
//父类  也称为  基类  
//Jave页面
class Jave : public BasePage//继承。
{
public:
	void centent()
	{
		cout << "Jave学科视频" << endl;
	}
};
//Python页面
class Python : public BasePage
{
public:
	void centent()
	{
		cout << "Python学科视频" << endl;
	}
};
//C++页面
class CPP : public BasePage
{
public:
	void centent()
	{
		cout << "C++学科视频" << endl;
	}
};

void test01()
{
	cout << "Jave下载视频页面如下：" << endl;
	Jave ja;//创建对象。
	ja.header();
	ja.footer();
	ja.left();
	ja.centent();
	cout << "-----------------------" << endl;
	cout << "Python下载视频页面如下：" << endl;
	Python py;//创建对象。
	py.header();
	py.footer();
	py.left();
	py.centent();
	cout << "-----------------------" << endl;
	cout << "C++下载视频页面如下：" << endl;
	CPP cpp;//创建对象。
	cpp.footer();
	cpp.left();
	cpp.centent();
	/*cout << "xxxxx" << endl;*/
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结:

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

class A : public B

A类称为子类或派生类

B类称为父类或基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

4.6.2继承方式

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

继承方式一共有三种：

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

#include<iostream>
using namespace std;
//继承方式
//公共继承
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 = 10;//父类中的保护权限成员 到子类中依然是保护权限
		//m_C=10;//父类中私有权限成员  子类访问不到
	}
};

void test01()
{
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B = 100;//到Son1中 m_B是保护权限  类外访问不到。
	cout <<"m_A=" <<s1.m_A<< endl;
}
//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 100;//父类中的公共权限成员 到子类中依然是公共权限
		m_B = 100;//父类中的保护权限成员 到子类中依然是保护权限
		//m_C=100;//父类中私有权限成员  子类访问不到
	}
};

void test02()
{
	Son2 s2;
	//s2.m_A = 100;//在Son2中 m_A是保护权限，因此类外访问不到。
	//s2.m_B = 100;//在Son2中 m_B保护权限 不可以访问。
}

//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 100;//父类中的公共权限成员 到子类中依然是公共权限
		m_B = 100;//父类中的保护权限成员 到子类中依然是保护权限
		//m_C=100;//父类中私有权限成员  子类访问不到
	}
};

void test03()
{
	Son3 s3;
	//s3.m_A = 1000;//在Son3中 变为  私有成员  类外访问不到。
	//s3.m_B = 1000;//在Son3中 变为  私有成员  类外访问不到。
}
//孙子继承
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//m_A = 1000;//到了Son3中 m_A变为私有，即使是儿子，也是访问不到的。
	}
};

int main()
{
	test01();

	system("pause");
	return 0;
}

4.6.3继承中对象模型

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

#include<iostream>
using namespace std;
//继承中的对象模型
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son :public Base
{
public:
	int m_D;
};
//利用开发人员命令提示工具查看对象模型
//跳转盘符 F：
//跳转文件路径 cd 具体路径下
// c1 /d1 reportSingleClassLayout类名 文件名
void test01()
{
	//在父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了。
	cout << "size of son =" <<sizeof(Son) << endl;//16 = 4 x 4
}

int main()
{
	test01();

	system("pause");
	return 0;
}

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

4.6.4继承中构造和析构顺序

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

问题：父类和子类的构造和析构顺序是谁先谁后？

#include<iostream>
using namespace std;
//继承中的构造和析构顺序
class Base
{
public:
	Base()
	{
		cout << "Base构造函数！" << endl;
	}
	~Base()
	{
		cout << "Base析构函数！" << endl;
	}
private:

};
class Son :public Base
{
public:
	Son()
	{
		cout << "Son构造函数！" << endl;
	}
	~Son()
	{
		cout << "Son析构函数！" << endl;
	}
};


void test01()
{
	//Base b;
	//继承中的构造和析构顺序如下：
	//先构造父类，在构造子类，析构的顺序和构造的顺序相反
	Son s;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

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

4.6.5继承同名成员处理方式

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

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

#include<iostream>
using namespace std;
//继承中同名成员处理
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;
private:

};

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

};

void test01()
{
	Son s;
	cout << "Son  下 m_A=" << s.m_A << endl;
	//如果通过子类对象  访问到父类中同名成员，需要加作用域
	cout << "Base 下 m_A=" << s.Base::m_A << endl;//添加父类的作用域
}
//同名成员函数处理
void test02()
{
	Son s;
	s.func();//直接调用 调用是子类中的同名成员。
	//如何调用到父类中同名成员函数？
	s.Base::func();
	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有的同名成员函数。
	//如果想访问到父类中被隐藏的同名成员含函数，需要加作用域
	s.Base::func(100);
}	

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

	system("pause");
	return 0;
}

总结:

1.子类对象可以直接访问到子类中同名成员

2.子类对象加作用域可以访问到父类同名成员

3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

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

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

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

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

#include<iostream>
using namespace std;

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;//类内声明，内外初始化。
private:

};
int Base::m_A = 100;//类内声明，内外初始化。

class Son:public Base
{
public:

	static int m_A;//类内声明，内外初始化。
private:

};
int Son::m_A = 200;//类内声明，内外初始化。
//同名静态成员属性
void test01()
{
	//1、通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	cout << "Son  下 m_A=" << s.m_A << endl;
	cout << "Base 下 m_A=" << s.Base::m_A << endl;
	//2、通过类名访问
	cout << "通过类名访问：" << endl;
	cout << "Son  下 m_A=" << Son::m_A << endl;
	//第一个::代表通过类名方式访问  第二个::代表访问父类作用域下
	cout << "Base 下 m_A=" << Son::Base::m_A << endl;
}
//同名静态成员函数
void test02()
{
	//1、通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	s.func();
	s.Base::func();

	//2、通过类名访问
	cout << "通过类名访问：" << endl;
	Son::func();
	Son::Base::func();
	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	//如果想访问父类中被隐藏同名成员，需要加作用域。
	Son::Base::func(100);
}

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

	system("pause");
	return 0;
}

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

4.6.7多继承语法

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

语法：class子类∶继承方式父类1，继承方式父类2……

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

C++实际开发中不建议用多继承

#include<iostream>
using namespace std;
//多继承语法
class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
private:

};

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

};
//子类  需要继承Base1和Base2
//语法：class 子类 ：继承方式  父类1，继承方式 父类2  ...
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 << "size of Son = " <<sizeof(s)<< endl;
	//当父类中出现同门成员，需要加作用域区分
	cout << "Base1 下 m_A = " << s.Base1::m_A << endl;
	cout << "Base2 下 m_A = " << s.Base2::m_A << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

4.6.8菱形继承

菱形继承概念：

两个派生类继承同一个基类

又有某个类同时继承者两个派生类

这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例：

菱形继承问题：

1.羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

2.草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

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

};
//利用虚继承，解决菱形继承的问题
//继承之前，加上关键字 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 = 20;
	//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	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;
}

总结：