2021-8-5 C++进阶学习 -＞ 4.6继承

目录

4.6.1 继承的基本语法

4.6.2 继承方式

4.6.3 继承中的对象模型

4.6.4 继承中构造和析构顺序

4.6.5 继承同名成员处理方式

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

4.6.7 多继承语法

4.6.8 菱形继承

---

4.6.1 继承的基本语法

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

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

//公告页面
//继承好处：减少重复代码
//语法：class 子类 : 继承方式 父类
//子类也称为派生类
//父类也成为基类
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;

	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;

	}
	void left()
	{
		cout << "Java 、Python、C++...(公共分类)" << endl;
	}
};

class Java :public BasePage
{
public:

	void content()
	{
			cout << "Java 学科视屏" << endl;
		}
};
class Python :public BasePage
{
public:

	void content()
	{
		cout << "Python 学科视屏" << endl;
	}
};
class CPP :public BasePage
{
public:

	void content()
	{
		cout << "cpp 学科视屏" << endl;
	}
};
//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()
{
	cout << "Java下载视屏界面如下：" << endl;
	Java ja;
	ja.header();
	ja.content();
	ja.footer();
	ja.left();

	cout << "-------------------" << endl;
	cout << "Python下载视屏界面如下：" << endl;
	Python py;
	py.header();
	py.content();
    py.left();
	py.footer();

	cout << "-------------------" << endl;
	cout << "c++下载视屏界面如下：" << endl;
	CPP c;
	c.header();
	c.content();
	c.left();
	c.footer();
}
int main() {

	test01();
	system("pause");
}

4.6.2 继承方式

4.6.3 继承中的对象模型

父类中所有属性都会被子类继承下去
 父类中私有成员属性被编译器隐藏，访问不到，但确实继承了

#include <iostream>
#include <string>
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;
};

void test01()
{
	//16
	//父类中所有属性都会被子类继承下去
	//父类中私有成员属性被编译器隐藏，访问不到，但确实继承了
	cout << "size of son is: " << sizeof(son) << endl;
}
int main() {

	test01();
	system("pause");
}

4.6.4 继承中构造和析构顺序

继承中的构造和析构顺序如下:
先构造父类，再构造子类，析构的顺序与构造的顺序相反
 

#include <iostream>
#include <string>
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()
{
	
	son sd;
}
int main() {

	test01();
	system("pause");
}

4.6.5 继承同名成员处理方式

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

son.Base::m_A;

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

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

void test01()
{
	son son;
	cout << "son中m_A的值为：" << son.m_A << endl;
	cout << "Base中m_A的值为："<<son.Base::m_A<< endl;
}

//同名函数处理方式
void test02()
{
	son s;
	s.func();
	s.Base::func();
	//如果子类中出现了和父类中同名的函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
}
int main() {
	test02();
	test01();
	system("pause");
}

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

静态成员属性1、通过对象访问2、通过类名来访问

同名静态函数1、通过对象访问2、通过类名访问

第一个代表类名访问，第二个：：代表父类作用域下访问
    cout << "Base下m_A:" << son::Base::m_A << endl;

#include <iostream>
#include <string>
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 -static void func()" << endl;
	}
};
int son::m_A = 200;

//静态成员属性
void test01()
{
	//1、通过对象访问
	cout << "通过对象访问" << endl;
	son s;
	cout << "m_A = " << s.m_A << endl;//son下
	cout << "m_A = " << s.Base::m_A << endl;//base下

	//2、通过类名来访问
	cout << "通过类名来访问" << endl;
	cout << "son下m_A:" <<son::m_A<<endl;
	//第一个代表类名访问，第二个：：代表父类作用域下访问
	cout << "Base下m_A:" << son::Base::m_A << endl;
}
//同名静态函数
void test02() {
	//1、通过对象访问
	son s;
	s.func();
	s.Base::func();

	//2、通过类名访问
	son::func();
	son::Base::func();

}
int main() {


	test02();
	test01();
	system("pause");
}

4.6.7 多继承语法

多继承语法：

class 子类：继承方式 父类,继承方式 父类，...

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

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_B = 10;
	}
	int m_B;
};
void test01()
{
	son s;
	cout << s.m_B << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}
int main() {

	test01();
	system("pause");
}

4.6.8 菱形继承

当出现菱形继承的时候，两个父类拥有相同数据，需要加以作用域区分
这份数据我们知道只要有一份就可以了，菱形继承导致数据有两份，资源浪费

利用虚继承可以解决菱形继承的问题
继承之前加上关键字 virtual变为虚继承

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

//动物类
class Animal {
public:

	int m_Age;
};
//利用虚继承可以解决菱形继承的问题
//继承之前加上关键字 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 = 28;
	//当出现菱形继承的时候，两个父类拥有相同数据，需要加以作用域区分
	//这份数据我们知道只要有一份就可以了，菱形继承导致数据有两份，资源浪费
	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;
}
int main() {

	test01();
	system("pause");
}