目录

1、派生的定义

2、派生的一般表达式

3、派生的类型

（1）公有型派生

（2）私有型派生

（3）保护型派生

 4、总结

---

1、派生的定义

        面向对象的主要特征：继承、封装和多态。

        继承（派生）：使一个类从现有的类中派生，而不用重新定义新类。其实质是用已有的数据类型创建新的数据类型，并保留已有的数据类型的特点。以旧类为基础创建新类，新类包含旧类的的数据成员和成员函数，并可以在新类中添加新的数据成员和成员函数。旧类被称为父类或基类，新类被称为派生类或子类。

2、派生的一般表达式

        class 派生类名称标识符 : [继承方式] 基类名称标识符

        // [继承方式],继承的基类成员的方式：public、protected、private；：是继承关系运算符。

        {

        [访问控制修饰符:] //派生类的访问控制类型：public、protected、private

        [成员声明列表] //派生类新增成员列表，继承来的成员不用重新列举

        }；

3、派生的类型

        继承方式有3种，其决定3种派生类型：分别为public、protected、private。访问控制修饰符也是此3种类型。

（1）公有型派生

1. 基类中所有public成员在派生类中为public属性；
2. 基类中所有protected成员在派生类中为protected属性；
3. 基类中所有private成员在派生类中不可访问。
4. 类体外的对象可以访问基类、子类的public型成员，不可以访问基类、子类的private、protected成员。

/*公有型派生*/
#include <iostream>
using namespace std;
class CEmployee								//定义基类
{
public:
	int m_ID;								//定义基类公有数据成员
	void Output()							//定义基类公有成员函数
	{
		cout << m_ID << endl;
		cout << m_Name << endl;
		cout << m_Depart << endl;
	}
	CEmployee()
	{
		m_ID = 111;
		strcpy_s(m_Name, 128, "MR");
		strcpy_s(m_Depart, 128, "KJ");
	}
private:											
	char m_Name[128];						 //定义基类私有数据成员
protected:
	char m_Depart[128];						 
};


class COperator :public CEmployee			//定义基类的子类，public派生类型
{
public:
	void Output()							//定义共有成员函数
	{
		cout << m_ID << endl;				//public派生类型子类可以访问基类public成员
		//cout << m_Name << endl;			//public派生类型子类不可以访问基类private成员，警告E0265
		cout << m_Depart << endl;			//public派生类型子类可以访问基类protected成员
		cout << m_Password << endl;			//public派生类型子类可以访问本子类private成员
	}
	COperator()
	{
		strcpy_s(m_Password, 128, "BONDER");
	}
private:
	char m_Password[128]{};					//定义子类的私有成员
	bool Login();							
};

int main(int argc, char* argv[])
{
	COperator optr;							//定义一个子类对象	
	//strcpy_s(optr.m_Name, 128, "MR");		//类域外通过对象不可访问基类的private成员，警告E0265
	//strcpy_s(optr.m_Password, 128, "KJ");	//类域外通过对象不可访问子类的private成员，警告E0265
	//optr.Login();							//类域外通过对象不可访问基类的private成员，警告E0265
	optr.CEmployee::Output();				//类域外通过对象可以访问基类的public成员
	optr.m_ID = 333;						//类域外通过对象可以访问基类的public成员
	/*strcpy_s(optr.m_Depart, 128, "HP");*/	//类域外通过对象不可访问基类的protected成员，警告E0265
	optr.Output();							//类域外通过对象可以访问子类的public成员
	/*optr.OutPutinfo();*/					//类域外通过对象不可访问子类的protected成员，警告E0265
	return 0;
}
/*运行结果：
111
MR
KJ
333
KJ
BONDER	*/

（2）私有型派生

1. 基类中的所有public成员在派生类中均为private属性；
2. 基类中的所有protected成员在派生类中均为private属性；
3. 基类中的所有private成员在派生类中均不可访问。
4. 类体外的对象只能访问子类的public型成员，不可以访问基类、子类的private、protected成员和基类的public型成员。因为这几种类型的成员都被子类私有化了。

/*私有型派生*/
#include <iostream>
using namespace std;
class CEmployee								//定义基类
{
public:
	int m_ID;								//定义基类公有数据成员
	void Output()							//定义基类公有成员函数
	{
		cout << m_ID << endl;
		cout << m_Name << endl;
		cout << m_Depart << endl;
	}
	CEmployee()
	{
		m_ID = 111;
		strcpy_s(m_Name, 128, "MR");
		strcpy_s(m_Depart, 128, "KJ");
	}
private:
	char m_Name[128];						 //定义基类私有数据成员
protected:
	char m_Depart[128];
};


class COperator :private CEmployee			//定义基类的子类，private派生类型
{
public:
	void Output()							//定义共有成员函数
	{
		cout << m_ID << endl;				//private派生类型子类可以访问基类public成员
		/*cout << m_Name << endl;	*/		//private派生类型子类不可以访问基类private成员，警告E0265
		cout << m_Depart << endl;			//private派生类型子类可以访问基类protected成员
		cout << m_Password << endl;			//private派生类型子类可以访问本子类private成员
	}
	COperator()
	{
		strcpy_s(m_Password, 128, "BONDER");
	}
private:
	char m_Password[128]{};					//定义子类的私有成员
	bool Login();
protected:
	void OutPutinfo()
	{
		cout << "保护好密码" << endl;
	};

};

int main(int argc, char* argv[])
{
	COperator optr;							//定义一个子类对象	
	//strcpy_s(optr.m_Name, 128, "MR");		//类域外通过对象不可访问基类的private成员，警告E0265
	//strcpy_s(optr.m_Password, 128, "KJ");	//类域外通过对象不可访问子类的private成员，警告E0265
	//optr.Login();							//类域外通过对象不可访问子类的private成员，警告E0265
	//optr.CEmployee::Output();				//类域外通过对象不可以访问基类的public成员，因为被子类私有了，警告E0265
	//optr.m_ID = 333;						//类域外通过对象不可以访问基类的public成员，因为被子类私有了，警告E0265
	//strcpy_s(optr.m_Depart, 128, "HP");	//类域外通过对象不可访问基类的protected成员，警告E0265
	optr.Output();							//类域外通过对象可以访问子类的public成员
	/*optr.OutPutinfo();*/					//类域外通过对象不可访问子类的protected成员，警告E0265
	return 0;
}
/*运行结果：
111
KJ
BONDER	*/

（3）保护型派生

1. 基类中的所有public成员在派生类中为protected属性；
2. 基类中的所有protected成员在派生类中为protected属性；
3. 基类中的所有private成员在派生类中仍然不可访问。
4. 类体外的对象只能访问子类的public型成员，不可以访问基类、子类的private、protected成员和基类的public型成员。因为这几种类型的成员都被子类保护了。

/*保护型派生*/
#include <iostream>
using namespace std;
class CEmployee								//定义基类
{
public:
	int m_ID;								//定义基类公有数据成员
	void Output()							//定义基类公有成员函数
	{
		cout << m_ID << endl;
		cout << m_Name << endl;
		cout << m_Depart << endl;
	}
	CEmployee()
	{
		m_ID = 111;
		strcpy_s(m_Name, 128, "MR");
		strcpy_s(m_Depart, 128, "KJ");
	}
private:
	char m_Name[128];						 //定义基类私有数据成员
protected:
	char m_Depart[128];
};


class COperator :protected CEmployee		//定义基类的子类，protected派生类型
{
public:
	void Output()							//定义共有成员函数
	{
		cout << m_ID << endl;				//protected派生类型子类可以访问基类public成员
		/*cout << m_Name << endl;	*/		//protected派生类型子类不可以访问基类private成员，警告E0265
		cout << m_Depart << endl;			//protected派生类型子类可以访问基类protected成员
		cout << m_Password << endl;			//protected派生类型子类可以访问本子类private成员
	}
	COperator()
	{
		strcpy_s(m_Password, 128, "BONDER");
	}
private:
	char m_Password[128]{};					//定义子类的私有成员
	bool Login();
protected:
	void OutPutinfo()
	{
		cout << "保护好密码" << endl;
	};

};

int main(int argc, char* argv[])
{
	COperator optr;							//定义一个子类对象	
	//strcpy_s(optr.m_Name, 128, "MR");		//类域外通过对象不可访问基类的private成员，警告E0265
	//strcpy_s(optr.m_Password, 128, "KJ");	//类域外通过对象不可访问子类的private成员，警告E0265
	//optr.Login();							//类域外通过对象不可访问子类的private成员，警告E0265
	//optr.CEmployee::Output();				//类域外通过对象不可以访问基类的public成员，因为被子类保护了，警告E0265
	//optr.m_ID = 333;						//类域外通过对象不可以访问基类的public成员，因为被子类保护了，警告E0265
	//strcpy_s(optr.m_Depart, 128, "HP");	//类域外通过对象不可访问基类的protected成员，警告E0265
	optr.Output();							//类域外通过对象可以访问子类的public成员
	/*optr.OutPutinfo();	*/				//类域外通过对象不可访问子类的protected成员，警告E0265
	return 0;
}
/*运行结果：
111
KJ
BONDER	*/

 4、总结

基类中的成员	在公有派生类中的访问属性	在私有派生类中的访问属性	在保护派生类中的访问属性
私有成员	不可访问	不可访问	不可访问
公用成员	公用	私有	保护
保护成员	保护	私有	保护
基类中的成员	公有派生类体外对象访问	私有派生类体外对象访问	保护派生类体外对象访问
私有成员	不可访问	不可访问	不可访问
公用成员	可访问	不可访问	不可访问
保护成员	不可访问	不可访问	不可访问
子类中的成员	公有派生类体外对象访问	私有派生类体外对象访问	保护派生类体外对象访问
私有成员	不可访问	不可访问	不可访问
公用成员	可访问	可访问	可访问
保护成员	不可访问	不可访问	不可访问

 注：以上程序在VS2022运行通过。