C++回顾（八）—— 继承

8.1 继承的概念

• 继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承类似，例如儿子继承父亲的财产。

• 继承（Inheritance）可以理解为一个类从另一个类获取成员变量和成员函数的过程。例如类 B 继承于类 A，那么 B 就拥有 A 的成员变量和成员函数。被继承的类称为父类或基类，继承的类称为子类或派生类。

• 派生类除了拥有基类的成员，还可以定义自己的新成员，以增强类的功能。

• 以下是两种典型的使用继承的场景：
  （1) 当你创建的新类与现有的类相似，只是多出若干成员变量或成员函数时，可以使用继承，这样不但会减少代码量，而且新类会拥有基类的所有功能。
  （2) 当你需要创建多个类，它们拥有很多相似的成员变量或成员函数时，也可以使用继承。可以将这些类的共同成员提取出来，定义为基类，然后从基类继承，既可以节省代码，也方便后续修改成员。

8.2 继承权限和继承方式

8.2.1 语法

• C++继承的一般语法为：

   class 派生类名:［继承方式］ 基类名
   {
        派生类新增加的成员
   };

• 继承方式限定了基类成员在派生类中的访问权限，包括 public（公有的）、private（私有的）和 protected（受保护的）。此项是可选项，如果不写，默认为 private（成员变量和成员函数默认也是 private）。

• 现在我们知道，public、protected、private 三个关键字除了可以修饰类的成员，还可以指定继承方式。

示例代码：

#include <iostream>
#include <cstring>

using namespace std;

class Person    //父类或者基类
{
//private:
protected:   //保护权限：类的内部可以访问，派生类内部可以访问，类的外部不能访问
	char name[32];
	int age;
public:
	Person()
	{
		strcpy(name, "aaa");
		age = 20;
	}
};

class Student : public Person   //子类或者派生类   public继承的权限
{
private:
	int id;
public:
	Student(int i)
	{
		this->id = i;
	}

	void show()
	{
		cout << name << " " << age << " " << id << endl;
	}
};

int main()
{
	Student s1(1);
	s1.show();

	return 0;
}

运行结果：

8.2.2 继承权限

• 不同的继承方式会影响基类成员在派生类中的访问权限。

1. public继承方式
   基类中所有 public 成员在派生类中为 public 属性；
   基类中所有 protected 成员在派生类中为 protected 属性；
   基类中所有 private 成员在派生类中不能使用。

2. protected继承方式
   基类中的所有 public 成员在派生类中为 protected 属性；
   基类中的所有 protected 成员在派生类中为 protected 属性；
   基类中的所有 private 成员在派生类中不能使用。

3. private继承方式
   基类中的所有 public 成员在派生类中均为 private 属性；
   基类中的所有 protected 成员在派生类中均为 private 属性；
   基类中的所有 private 成员在派生类中不能使用。

• 通过上面的分析可以发现：

1. 基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。

   也就是说，继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。

2. 不管继承方式如何，基类中的 private 成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。

3. 如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为 public 或 protected；只有那些不希望在派生类中使用的成员才声明为 private。

4. 如果希望基类的成员既不向外暴露（不能通过对象访问），还能在派生类中使用，那么只能声明为 protected。

   注意，我们这里说的是基类的 private 成员不能在派生类中使用，并没有说基类的 private 成员不能被继承。实际上，基类的 private 成员是能够被继承的，并且（成员变量）会占用派生类对象的内存，它只是在派生类中不可见，导致无法使用罢了。private 成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性。

• 下表汇总了不同继承方式对不同属性的成员的影响结果
  
  示例代码：

#include <iostream>

using namespace std;

class TestA
{
private:
	int a;    //只能在类的内部访问
protected:
	int b;
public:
	int c;
};

//私有继承
class TestB : private TestA 
{
/*
	int a;
private:
	int b;
private:
	int c;*/
public:
	void test()
	{
		//a++;   //在TestA中，a是私有成员变量，不能访问
		b++;
		c++;
	}
};

//保护继承
class TestC : protected TestA
{
/*
	int a;
protected:
	int b;
protected:
	int c;*/
public:
	void test()
	{
		//a++;
		b++;
		c++;
	}
};

//公有继承
class TestD : public TestA
{
/*
	int a;
protected:
	int b;
public:
	int c;*/
public:
	void test()
	{
		//a++;
		b++;
		c++;
	}
};

//继承权限：限制了成员在派生类中的最高权限
int main()
{
	TestB tb;
	//tb.b;
	//tb.c;

	TestD td;
	//td.b;
	td.c;

	return 0;
}

8.3 继承中的构造和析构

8.3.1 继承中的对象模型

• 派生类的内存布局：先存放父类成员，再存放子类成员

示例代码：

#include <iostream>

using namespace std;

class Person
{
public:
	int age;
};

class Student : public Person
{
public:
	int id;
};

int main()
{
	Student s;
	cout << sizeof(s) << endl;

	cout << &s << endl;  //派生类的内存布局：先存放父类成员，再存放子类成员
	cout << &s.age << endl;
	cout << &s.id << endl;

	return 0;
}

运行结果：

8.3.2 继承中的构造、析构调用原则

• 1、子类对象在创建时会首先调用父类的构造函数
• 2、父类构造函数执行结束后，执行子类的构造函数
• 3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
• 4、析构函数调用的先后顺序与构造函数相反
  

8.3.3 继承与组合混搭情况下，构造和析构调用原则

原则：

• 先构造父类，再构造成员变量、最后构造自己
• 先析构自己，在析构成员变量、最后析构父类
• 先构造的对象，后释放
  

示例代码：

#include <iostream>
#include <cstring>

using namespace std;

class Person    //父类或者基类
{
//private:
protected:   //保护权限：类的内部可以访问，派生类内部可以访问，类的外部不能访问
	char name[32];
	int age;
public:
	/*Person()
	{
		cout << "Person构造函数" << endl;
		strcpy(name, "aaa");
		age = 20;
	}*/
	Person(const char *n, int a)
	{
		cout << "Person有参构造函数" << endl;
		strcpy(name, n);
		age = a;
	}
	~Person()
	{
		cout << "Person析构函数" << endl;
	}
};

class Date
{
protected:
	int year;
	int mouth;
	int day;
public:
	Date(int y, int m, int d)
	{
		cout << "Date有参构造函数" << endl;
		year = y;
		mouth = m;
		day = d;
	}
	~Date()
	{
		cout << "Date析构函数" << endl;
	}
};

class Student : public Person   //子类或者派生类   public继承的权限
{
private:
	Date birth;   //先构造父类，再构造成员，最后构造自己
	int id;
public:
	//当基类没有提供无参构造函数的时候，派生类需要通过对象初始化列表来传参
	Student(int i) : Person("aaa", 23), birth(1, 1, 1)
	{
		cout << "Student构造函数" << endl;
		this->id = i;
	}

	void show()
	{
		cout << name << " " << age << " " << id << endl;
		//cout << id << endl;
	}
	~Student()
	{
		cout << "Student析构函数" << endl;
	}
};

int main()
{
	Student s1(1);   //创建派生类对象，会先调用父类构造函数，来初始化继承来的成员
	s1.show();

	return 0;       //析构的顺序跟构造相反
}

运行结果：

8.3.4 继承中的同名成员变量处理方法

• 1、当子类成员变量与父类成员变量同名时
• 2、子类依然从父类继承同名成员
• 3、在子类中通过作用域分辨符::进行同名成员区分（在派生类中使用基类的同名成员，显式地使用类名限定符）
• 4、同名成员存储在内存中的不同位置

示例代码：

#include <iostream>

using namespace std;

class TestA
{
private:
	int a;
public:
	void show()
	{
		cout << "this is TestA" << endl;
	}
};

class TestB : public TestA
{
private:
	int a;
public:
	void show()
	{
		cout << "this is TestB" << endl;
	}
};

int main()
{	
	TestB tb;
	cout << sizeof(tb) << endl; 

	tb.show();  //同名成员函数，默认调用子类成员函数；变量也一样
	tb.TestA::show();

	return 0;
}

运行结果：

8.3.5 派生类中的static关键字

继承和static关键字在一起会产生什么现象呢？

• 理论知识
  基类定义的静态成员，将被所有派生类共享

  根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质 （遵守派生类的访问控制）

  派生类中访问静态成员，用以下形式显式说明：
  类名 :: 成员 或 通过对象访问 对象名 . 成员

• 总结：
  （1）static函数也遵守3个访问原则
  （2）static易犯错误（不但要初始化，更重要的显示的告诉编译器分配内存）

示例代码：

#include <iostream>

using namespace std;

class Person
{
public:
	static int count;
public:
	Person()
	{
		count++;
	}
};
int Person::count = 0;

class Student : public Person
{

};

int main()
{
	Student s1;
	Student s2;
	Student s3;
	Person p1;
	Person p2;

	cout << Person::count << endl;  //派生类和基类共享同一个静态成员变量
	cout << Student::count << endl;

	
	return 0;
}

运行结果：