c++学习---继承与派生类

1.继承

继承性是面向对象程序设计当中最重要的机制，这种机制可以无限度的重复利用程序的
资源。通过C++语言中的继承机制，我们可以扩充和完善旧的程序设计以适应新的需求。
这样不仅可以节省程序开发的时间和资源，并且能够为未来程序增添新的功能需求提供了便
利。

1、首先我们写一个学生类，用以统计并存储学生的信息。

class student
{
public:
	//构造函数
	student(int a, string b, string sex);
	~student() { cout << "调用基类student的析构函数!\n"; }
	//成员函数
	void show();

	int x = 10;//测试同名属性的调用
private:
	int num;//学号
	string name;//名字
	string sex;//性别
	
};

2.一段时间后，项目需要增添新的需求，我们就要在原项目上增添新的功能，添加其他
信息。

难道需要在原来的类基础上进行增添修改？如果开发过程中修改了参数会影响现在的运行怎么办？如果增加几行还好，如果增加几千行呢？因此就需要继承了，使类与类隔离，只需在新的类修改即可。

在C++中所谓 “继承” 就是在一个已存在的类的基础上建立一个新的类。原来已存在
的被继承的类称为“基类(base class)”或“父类(father class)”。新建立的继承的类被称
为“派生类(derived class)”或“子类(son class)”。

class student1
{
public:
	//构造函数
	student1(int c, string s);
	~student1(){ cout<< "调用基类student1的析构函数!\n"; }
	void show_1();//新增成员函数

	int x = 100;//测试同名属性的调用
private:
	int age; //新增年龄属性
	string addr;//新增数据成员

	
	
};

class student2 : public student, public student1
{
public:
	//初始化类值，使用构造函数进行传参
	student2(int a, string b, string sex, int c, string s, float score, string grade);
	~student2() { cout << "调用派生类的析构函数!\n"; }
	//成员函数
	void show_2();

	int x = 1000;//测试同名属性的调用
private:
	float score;//分数
	string grade;//年级
	//基类对象，测试构造函数的调用顺序
	student s,ss;
	
};

多继承

在C++语言中，一个派生类可以从一个基类派生，也可以从多个基类派生。
从一个基类派生的继承称为单继承；
从多个基类派生的继承称为多继承；
通过继承机制，我们可以利用已有的数据类型来定义新的数据类型。所定义的新的数据
类型不仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类
为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。
在建立派生类的过程中，基类不会做任何改变，派生类则除了继承基类的所有可引用的
成员变量和成员函数外，还可另外定义本身的成员变量和处理这些变量的函数，由于派生类
可继承基类的成员变量和成员函数，因此在基类中定义好的数据和函数等的程序代码可重复
使用，这样可以提高程序的可靠性。
当从已有的类中派生出新的类时，可以对派生类做以下几种变化：
1、可以继承基类的成员数据和成员函数。
2、可以增加新的成员变量。
3、可以增加新的成员函数。
4、可以重新定义已有的成员函数。
5、可以改变现有的成员属性。
在C++语言中有二种继承方式：单一继承和多重继承。当一个派生类仅由一个基类派
生时，称为单一继承；而当一个派生类由二个或更多个基类所派生时，称为多重继承。
从一个基类派生一个类的一般格式为：

class <派生类名>:<继承方式> <基类名>
{
private:
  ......； // 私有成员说明
public:
  ......； // 公有成员说明
protected:
  ......； // 保护成员说明
｝
// 继承方式同样分为以下三种：
public: 表示公有派生
private: 表示私有派生(不写继承方式的情况下默认私有继承)
protected: 表示保护派生

// 多重继承
class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
  <派生类类体>
};

公有派生、私有派生、保护派生

访问控制和继承
派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访
问，则应在基类中声明为 private。
一个派生类继承了所有的基类方法，但以下情况除外：
基类的构造函数、析构函数和拷贝构造函数。
基类的重载运算符。
基类的友元函数。
公有派生
基类中所有成员在派生类中继承之后，各个成员的访问权限保持不变。

派生方式               派生类中             派生类外
public（公有）     可以访问             可以访问
private（私有）    不可访问            不可访问
protected（保护）可以访问            不可访问

基类的属性：
public: 在派生类和派生类外都可以使用
private: 派生类和派生类外都无法使用
protected: 只能在派生类中使用

/*
* 公有派生
* 基类的属性：
	public: 在派生类和派生类外都可以使用
	private: 派生类和派生类外都无法使用
	protected: 只能在派生类中使用
总结：	派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private
		类外可以访问公开继承的公开成员
*/
class A
{
public:
	int x=10;
private:
	int y=20;
protected:
	int z=30;
};

class B:public A //类B公开继承类A
{
public:
	void show()
	{
		cout << x << endl;
		//cout << y << endl;//类内无法访问公开继承A的私有成员
		cout << z << endl;
	}
private:

};

私有派生
私有派生时，基类中公有成员和保护成员在派生类中均变为私有的，不过在派生类中仍
可直接使用这些成员。而基类中的私有成员，在派生类中则无法访问。
派生方式                派生类                    派生类外
public（公有）      可以访问                 不可访问
private（私有）     不可访问                不可访问
protected（保护） 可以访问                不可访问
基类的属性：
public: （变为私有）只能在派生类中使用
private: 派生类和派生类外都无法使用
protected:（变为私有） 只能在派生类中使用

/*
* 私有派生
* 基类的属性：
	public: （变为私有）只能在派生类中使用
	private: 派生类和派生类外都无法使用
	protected:（变为私有） 只能在派生类中使用
总结：	私有派生时，基类中公有成员和保护成员在派生类中均变为私有的，不过在派生类中仍
		可直接使用这些成员。而基类中的私有成员，在派生类中则无法访问
		私有继承，派生类外均无法访问
*/

class A
{
public:
	int x = 10;
private:
	int y = 20;
protected:
	int z = 30;
};

class B :private A //类B私有继承类A
{
public:
	void show()
	{
		cout << x << endl; // 类内可以访问私有继承的公开成员
		//cout << y << endl;//类内无法访问私有继承的私有成员
		cout << z << endl; //类内可以访问私有继承的保护成员
	}

};

class C :private B
{
public:
	void show1()
	{
		//cout << x << endl;//类内无法访问私有继承之后转换为私有的公开成员
		//cout << y << endl;//类内无法访问私有继承之后转换为私有的私有成员
		//cout << z << endl;//类内无法访问私有继承之后转换为私有的保护成员
	}
};

保护派生
保护派生时，基类中公有成员和保护成员在派生类中均变为保护成员，在派生类中仍可
直接使用这些成员，基类中的私有成员，在派生类中不可直接使用。
派生方式                 派生类                    派生类外
public（公有）       可以访问                无法访问
private（私有）      无法访问                无法访问
protected（保护）  可以访问                无法访问
基类的属性：
public: （变为保护）只能在派生类中使用
private: 派生类和派生类外都无法使用
protected:（变为保护） 只能在派生类中使用

/*
* 保护派生
* 基类的属性：
	public: （变为保护）只能在派生类中使用
	private: 派生类和派生类外都无法使用
	protected:（变为保护） 只能在派生类中使用
总结：	保护派生时，基类中公有成员和保护成员在派生类中均变为保护成员，在派生类中仍可
		直接使用这些成员，基类中的私有成员，在派生类中不可直接使用。
*/


class A
{
public:
	int x = 10;
private:
	int y = 20;
protected:
	int z = 30;
};

class B :protected A //类B保护继承类A
{
public:
	void show()
	{
		cout << x << endl; // 类内可以访问保护继承的公开成员（转为保护）
		//cout << y << endl;//类内无法访问保护继承的私有成员
		cout << z << endl; //类内可以访问保护继承的保护成员(还是保护，不变)
	}

};

class C :private B
{
public:
	void show1()
	{
		cout << x << endl;//类内可以访问保护继承之后转换为保护的公开成员(转化为保护，可以访问)
		//cout << y << endl;//类内无法访问保护继承之后转换为私有的私有成员(私有不可访问)
		cout << z << endl;//类内可以访问保护继承之后转换为保护的保护成员（保护可以访问）
	}
};

抽象类与保护的成员函数

当定义了一个只能用作基类来派生新类的类，不能用这种类来定义对象时，称这种类为
抽象类。当对某些特殊的对象要进行很好地封装时，需要定义抽象类。
将类的构造函数或析构函数的访问权限定义为保护的时，这种类为抽象类。
如果类中的构造函数或析构函数说明为私有的时，所定义的类通常是没有任何实用意义
的，一般情况下，不能用它来产生对象，也不能用它来产生派生类