第一百零一天学习记录：C++核心：类和对象Ⅵ（五星重要）继承上

继承

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

继承的基本语法

普通写法：

#include <iostream>
using namespace std;

//普通实现页面

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

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

//C++页面
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.footer();
	ja.left();
	ja.content();
	cout << "------------------------------------" << endl;
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "------------------------------------" << endl;
	cout << "C++下载视频页面如下：" << endl;
	Cpp cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}

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

继承写法：

#include <iostream>
using namespace std;

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

//公共页面类

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

void test01()
{
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "------------------------------------" << endl;
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "------------------------------------" << endl;
	cout << "C++下载视频页面如下：" << endl;
	Cpp cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}

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

问：C++继承一个类可以写成：Class lei1:public lei2，那如果继承两个类该怎么写呢？
答：
在C++中，可以通过使用逗号分隔的方式来实现从多个类继承。下面是一个示例：

class BaseClass1 {
    // BaseClass1的成员和方法
};

class BaseClass2 {
    // BaseClass2的成员和方法
};

class DerivedClass : public BaseClass1, public BaseClass2 {
    // DerivedClass的成员和方法
};

在该示例中，DerivedClass 继承自 BaseClass1 和 BaseClass2。请注意，多重继承需要注意解决可能出现的命名冲突问题。

继承方式

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

继承方式一共有三种：
1、公共继承
2、保护继承
3、私有继承

注：截图转自黑马程序员免费教学视频

//公共继承
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;//父类中的私有权限成员 到子类中无法访问
	}
};

//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//私有继承
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;//父类中的私有权限成员 到子类中无法访问
	}
};

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

class GrandSon3 :public Son3
{
	void func()
	{
		//m_A = 1000;//到了Son3中 m_A变为私有，及时是儿子，也是访问不到
		//m_B = 1000;
	}
};

void test01()
{
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B = 100;//类外无法访问类内，有保护权限
}

void test02()
{
	Son2 s2;
	//s2.m_A = 1000;//在Son2中 m_A变为保护权限，因此类外访问不到
	//s2.m_B = 1000;//在Son2中 m_A变为保护权限，不可用访问
}

void test03()
{
	Son2 s3;
	//s3.m_A = 1000;//在Son2中 m_A变为私有权限，因此类外访问不到
	//s3.m_B = 1000;//在Son2中 m_A变为私有权限，不可用访问
}

int main()
{
	return 0;
}

继承中的对象模型

#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;
};

//利用开发人员命令提示工具查看对象模型
//跳转盘符 （如果有需要）
//跳转文件路径 cd 具体路径下
//查看命名
//cl /d1 reportSingleClassLayout类名 文件名

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

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

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

继承中的构造和析构顺序

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

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

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

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