面向对象编程：继承的概念与应用-优快云博客

本文链接：https://blog.youkuaiyun.com/shidian1/article/details/125036681

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

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

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

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

4.6.1 继承的基本语法

例如我们看到很多网站中，都用公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同。接下来我们分别利用普通写法和继承写法来实现网页中的内容，看一下继承存在的意义以及好处。

#include<stdc++.h>
using namespace std;


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

//继承的好处：减少重复代码
//语法：class 子类：继承方式 BasePage 父类
//子类 也称为 派生类
//父类 也称为 基类

//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 << "CPP学科视频" << endl;
	}
};

void test01()
{
	cout << "Java下载视频页面如下：	" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();

}

int main()
{
	test01();
}

总结：

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

class A:public B;

A类称为子类或派生类

B类称为父类或基类

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

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

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

4.6.2 继承方式

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

继承方式一共有三种：

公共继承

保护继承

私有继承

#include<stdc++.h>
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是保护权限 类外访问不到
}

//保护继承
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 s1;
	//s1.m_A = 1000;//在Son2 中 m_A变为保护权限，因此类外访问不到
}

//私有继承
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 s1;
	//s1.m_A = 1000;//到Son3中 变为 私有成员 类外访问不到
}

class Grandson3 :public Son3
{
public:
	void func()
	{
		//m_A = 1000;//父类中私有成员访问不到
	}
};

int main()
{

	return 0;
}

4.6.3 继承中的对象模型

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

#include<stdc++.h>
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 已复制的路径单机右键
//查看命名
// cl /d1 reportSingleClassLayout类名 文件名（Tab可自动补全文件名）

void test01()
{
	//父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器给隐藏了，因此访问不到，但是确实是被继承下去了
	cout << "size of Son = " << sizeof(Son) << endl;
}

int main()
{
	test01();
}

4.6.4 继承中构造和析构顺序

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

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

#include<stdc++.h>
using namespace std;

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()
{
	//Base b;

	//继承中的构造和析构顺序如下：
	//先构造父类,在构造子类，析构的顺序与构造的顺序相反
	Son s1;
}

int main()
{
	test01();

}

4.6.5 继承同名成员处理方式

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

访问子类同名成员直接访问即可

访问父类同名成员需要加作用域

#include<stdc++.h>
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;
};

class Son :public Base
{
public:

	Son()
	{
		m_A = 200;
	}

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


	int m_A;
};

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();
	return 0;
}

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

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

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

访问子类同名成员直接访问即可

访问父类同名成员需要加作用域

#include<stdc++.h>
using namespace std;

//继承中的同名静态成员处理方式

class Base
{
public:
	static int m_A;

	static void func()
	{
		cout << "Base-static void func()" << endl;
	}
};
int Base::m_A = 100;

class Son :public Base
{
public:
	static int m_A;

	static void func()
	{
		cout << "Son Base-static void func()" << endl;
	}
};
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();

	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	//如果想访问父类中被隐藏同名成员，需要加作用域
}


int main()
{
	test01();
	test02();
	return 0;
}

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

4.6.7多继承语法

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

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

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

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

#include<stdc++.h>
using namespace std;

//多继承语法

class Base1
{
public:

	Base1()
	{
		m_A = 100;
	}

	int m_A;
};

class Base2
{
public:

	Base2()
	{
		m_A= 200;
	}

	int m_A;
};

//子类 需要继承Base1和Base2
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 << "m_A=" << s.Base2::m_A<< endl;
}


int main()
{

	test01();

	system("pause");

	return 0;
}

总结：多继承中如果父类中出现了同名情况，子类使用时候要加作用域

4.6.8 菱形继承

菱形继承概念：

两个派生类继承同一个基又有某个类同时继承这两个派生类这种继承被称为菱形继承

菱形继承问题：

1.🐏继承了动物的数据，🐫同样继承了动物的数据，当似羊驼使用数据时，就会产生二义性

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

#include<stdc++.h>
using namespace std;

//动物类

class Animal
{
public:
	int m_Age;
};

//利用虚继承 解决菱形继承的问题
//继承之前 加上关键字 virtual 变为虚继承
//Animal类称为 虚基类

//羊类
class Sheep :virtual public Animal
{
};

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

//羊驼类
class Alpaca :public Sheep,public Camel
{

};

void test01()
{
	Alpaca st;

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

	//这份数据我们知道 只要有一份就可以了，菱形继承导致数据有两份，资源浪费
}



int main()
{
	test01();

}

总结：

菱形继承带来的主要问题是子类继承两份相同的数据，导致资源的不必要浪费

利用虚继承可以解决继承问题

虚继承的一点补充（虚指针通过量的偏移指向唯一继承的数据）