C++继承（一）

1. 继承的概念以及定义

1.1 继承的概念

继承机制是面向对象程序设计使代码可以复用的最重要手段，它允许程序员在保持原有的类特性的基础上进行扩展，增加功能，这样产生新的类，称为派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触到的复用都是函数复用，继承是设计层次的复用。

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18;  // 年龄
};

class Student : public Person
{
protected:
	int _stuid; // 学号
};
class Teacher : public Person
{
protected:
	int _jobid; // 工号
};

使用继承后，person中的成员都会变成子类中的一部，这里就体现两个子类复用person中的成员。

1.2 继承定义

1.2.1定义格式 :

1.2.2继承关系和访问限定符

继承方式：

1. public继承
2. protected 继承
3. private 继承

访问限定符

1. public 访问
2. protected 访问
3. private 访问

1.2.3继承基类成员访问方式的变化

基类中的成员被不同的访问限定符修饰，再不同的继承方式继承到派生类中，继承基类成员访问方式也不同。

通过上面的表格我们可以总结出：

1. 三种权限大小为： public > protected > private
2. 基类成员在其他类中的访问方式 == Min(成员在基类的访问限定符，继承方式）
3. 基类中的成员若是private访问方式，则在派生类中都不可见。

怎样理解基类中基类private成员在派生类中不可见？

总的来说就是基类的private成员，在派生类中不能访问。
我们通过下面的代码来理解：

class Person
{
public :
 void Print ()
 {
 cout<<_name <<endl;
 }
protected :
 string _name ; // 姓名
private :
 int _age ; // 年龄
};
class Student : public Person
{
protected :
 int _stunum ; // 学号
};

虽然student类继承了person类，但是我们在student中却无法访问person中private成员_age。
所以基类中private成员不管使用什么继承方式，在派生类中都是不可访问的。不仅仅是在派生的，即使实在类外面也无法访问，基类中的private成员只能在基类本身类里面访问。
这也是protected出现的原因。若是基类protected成员，在派生类中就能够访问。

我们在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。、

1.2.4 struct 和 class 的默认继承方式

在继承中可以不定义继承方式， struct 的默认继承方式为public ， class 的默认继承方式为private。
例如： struct 默认继承方式为public ，即使基类中的都为private成员，继承到的成员的访问方式为public。

class person{
public:
	string _name = "张三";

};
struct Student : person
{
protected:
	int _stunum; // 学号
};

而class的默认继承方式为private，继承的即使是public成员，访问方式变为private。

class person{
private:
	string _name = "张三";

};
class Student : person
{
protected:
	int _stunum; // 学号
};

2. 基类和派生类对象赋值转换

我们都知道不相关类型之间是不能转换的，即使强制类型转换也不可以。

那子类可以转换成父类吗？ 答案是可以的，但是前提是必须是public继承才可以。
可以这么说每一个子类对象都是一个特殊的父类对象（is-a）。原因是子类中的成员在父类中也同时存在 。
我们把子类赋值给父类这一操作叫做 切割/切片 。派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。寓意把派生类中父类那部分切来赋值过去。

切割赋值兼容规则：
在子类赋值给父类的过程中间不产生临时变量。
例一：子类直接赋值给父类，将父类的那一部分拷贝给父类。

例二： 子类给给父类的引用，就是在子类中父类的那一部分的别名切片给父类。

例三：子类赋值给父类的指针，也是在子类中把父类那一部分的指针给父类。

注意：

1. 基类对象不能赋值给派生类对象。
2. 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

3. 继承中作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

class person{
protected :
	string _name = "张三";
	int _age = 36;
};

class Student : person
{
public:
	void print()
	{
		cout << _age << endl; //默认访问的是子类中的_age，这就构成隐藏
		cout << person::_age << endl;//若是想访问父类中的_age
	}
protected:
	int _stunum; // 学号
	int _age = 18;
};

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员

4. 派生类中的默认成员函数

观察以下代码：
基类为person

class person{
public:
	person(const char* name)
		:_name(name)
	{}

	person(const person& p)
		:_name(p._name)
	{}
	person& operator=(const person& p)
	{
		if(this != &p)
		_name = p._name;
		return *this;
	}
	~person()
	{
		cout << "~Person()" << endl;
	}

protected :
	string _name ;
};

让student继承person类，student为派生类。

class Student : person
{
public:
	Student(const char* str,const int  & stunum,const int& age )
		:person(str)
		,_stunum(stunum)
		,_age(age)
	{}

	Student(const Student& s)
		:person(s)
		,_stunum(s._stunum)
		,_age(s._age)
	{}
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			person::operator=(s);
			_age = s._age;
			_stunum = s._stunum;
		}
		return *this;
	}
	void print()
	{
		cout << "姓名:" << person::_name<<endl;
		cout << "学号:" << _stunum << endl;
		cout << "年龄:" << _age << endl;
	}
	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _stunum; // 学号
	int _age ;
};

可以发现派生类与普通类的默认成员有所不同主要体现在以下几点：

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
   

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
   

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
   

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。