继承（CPP）

引言

继承是CPP的一个重要语法。在现实生活中存在“子承父业”的说法，在CPP中同样存在这样的语法，而继承就是这种语法。

面向对象的三大特征：封装、继承、多态

本文将通过以下要素，进行继承的深入讲解

1.继承的概念及定义 2.基类和派生类对象赋值转换 3.继承中的作用域 4.派生类的默认成员函数 5.继承与友元 6.继承与静态成员 7.复杂的菱形继承及菱形虚拟继承 8.继承的总结和反思

1.继承的概念及定义

继承的概念

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

继承的本质是类的复用，为什么会出现类的复用呢？生活中其实有大量类的复用的例子。假如我们的学校教务处想要开发一款教务管理工具，需要管理学生，也需要管理老师。老师和学生都是人，只不过是学号、工号不同，因此可以将“人”这个对象抽象出一个单独的类，去复用这个类，而学生、教工就可以继承“人”这个类的概念。

   这就是继承（子承父业），下面继承上面（公共部分）。上面叫做父类、基类，下面叫子类、派生类

继承的格式

继承的格式体现在派生类。当student类继承person类时，格式为student：person。

Person是父类，也称作基类。Student是子类，也称作派生类。public是继承方式

继承之后可以复用成员函数与成员变量。

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

继承关系和访问限定符

访问限定符分为：public、private、protected

其权限大小是public>protected>private

如何理解呢？public是共有设施；protected是家庭私有财产，允许继承之后使用；private则像是爸爸的私房钱，只能爸爸使用。

因此后两个在类外部不能使用，private继承之后也不能直接访问。

protected和private区别（cpp）

在C++中，protected和private都是访问修饰符，用于控制类的成员变量和成员函数的访问权限。以下是它们之间的主要区别：

private（私有）：

1. 访问权限：当成员被声明为private时，它们只能被同一个类中的函数访问，不能被类的实例或者派生类访问。
2. 封装性：private成员用于实现类的内部工作，对外部隐藏实现细节，是面向对象编程中封装特性的体现。
3. 继承：在继承关系中，基类的private成员不会被派生类继承，即在派生类中无法直接访问基类的private成员。

protected（受保护的）：

1. 访问权限：protected成员可以被同一个类中的函数访问，也可以被派生类中的函数访问，但是不能被类的实例直接访问。
2. 继承：当类被继承时，protected成员在派生类中保持protected的访问级别，这意味着派生类的成员函数可以访问基类的protected成员，但类的用户代码不能直接访问。
3. 封装性：protected提供了一种比public更严格的访问级别，但比private更宽松，允许派生类访问基类的特定成员，这在实现某些继承关系时非常有用。

在选择使用protected还是private时，通常遵循最小权限原则，即尽可能使用private，只在需要让派生类访问基类特定成员时使用protected。这样可以保证类的封装性，同时提供必要的灵活性。

总结：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected> private。

4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

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

这种继承是最常见的。

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

一般类型的转化

在我们之前的知识可以知道，相近类型的赋值要隐式类型转换，隐式类型转化要产生临时对象！！！也就是说，只要是隐式转化发生，就总是得产生一个常性的临时对象。

表示数据的多少int、double可以转化赋值。r引用的不是d，而是一个临时对象，常性

xxx赋值给string对象，可以看出自定义类型也要产生临时对象

那派生类和基类是如何进行的呢？

最常用的继承就是公有继承，公有继承可以理解成is-a的关系。即父子之间的赋值存在特殊的规则。

student继承person

可以观察到对象s可以直接赋值给对象p。

当然p类型的引用可以直接引用s（p是基类，s是派生类）。

为什么不需要const引用，而可以直接引用呢？原因就是is-a规则。

当子类赋值给父类时，我们可以人为是直接赋值，而不是产生了临时对象。

规则

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片 或者切割。寓意把派生类中父类那部分切来赋值过去。这是赋值兼容规则。

父类将获得子类继承的那一部分。

注意：

基类对象不能赋值给派生类对象。

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类 的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。

当派生类对象赋值给基类对象时，通过基类对象调用的成员函数是基类的函数，而不是派生类中覆盖（override）后的版本

3.继承中的作用域

首先我们要明确，基类和派生类都有独立的花括号{}，因此他们属于独立的作用域。

关于继承中作用域相关现象的解释：

1. 在继承体系中 基类和 派生类都有 独立的作用域。

2. 子类和父类中有同名成员， 子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，

也叫重定义。（在子类成员函数中，可以 使用 基类::基类成员 显示访问）

3. 需要注意的是如果是成员函数的 隐藏，只需要 函数名相同就构成隐藏。

4. 注意在实际中在 继承体系里面最好 不要定义同名的成员。

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected :
 string _name = "小李子"; // 姓名
 int _num = 111;   // 身份证号
};
class Student : public Person
{
public:
 void Print()
 {
 cout<<" 姓名:"<<_name<< endl;
 cout<<" 身份证号:"<<Person::_num<< endl;
 cout<<" 学号:"<<_num<<endl;
 }
protected:
 int _num = 999; // 学号
};
void Test()
{
 Student s1;
 s1.Print();
};

打印_num时，打印的时999而不是111，这就是构成了成员变量的隐藏。

当我们想要访问基类的_num时，需要点明作用域

观察下面的代码：

// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
 void fun()
 {
 cout << "func()" << endl;
 }
};
class B : public A
{
public:
 void fun(int i)
 {
 A::fun();
 cout << "func(int i)->" <<i<<endl;
 }
};
void Test()
{
 B b;
 b.fun(10);
};

这是关于两个fun的解释：

// B 中的 fun 和 A 中的 fun 不是构成重载，因为不是在同一作用域

// B 中的 fun 和 A 中的 fun 构成隐藏，成员函数满足函数名相同就构成隐藏。

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

6个默认成员函数， “默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类

中，这几个成员函数是如何生成的呢？

规则：

1. 派生类的构造函数 必须调用基类的构造函数初始化基类的那一部分成员。如果基类 没有默认

的构造函数，则必须在派生类构造函数的 初始化列表阶段显示调用（构造函数先执行初始化列表，再执行函数体）。(存在默认构造会在初始化列表阶段调用默认构造）

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

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

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能

保证派生类对象先 清理派生类成员再清理基类成员的顺序。

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

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

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

构造函数

如果想显式定义构造函数，那么C++规定，必须把父类当成一个完整的对象去初始化。如果不写，会去调用父类的默认构造。

这是基类：person

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

派生类：student类的构造实现（公有继承）

class Student : public Person

实现：
 

Student(const char* name, int id)
	:_id(id)
	, Person(name)
{
	cout << "Student(const char* name, int id)" << endl;
}

id用来初始化成员变量_id，name用来初始化基类Person

可以看到，在初始化列表阶段，先调用了基类的构造，然后函数体执行了派生类的构造。

拷贝构造

拷贝构造需要完成基类部分的拷贝

Person(const Person& p)
	: _name(p._name)
{
	cout << "Person(const Person& p)" << endl;
}

在派生类如何传参进行基类的拷贝呢？

其实只需要传入派生类对象就可以。这就是赋值兼容规则。在引用中，会截取父类的部分去完成父类拷贝构造的调用。

Student(const Student& s)
	:Person(s)
	, _id(s._id)
{
	cout << "Student(const Student& s)" << endl;
}

赋值重载

这是父类的赋值重载

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

派生类的赋值重载可以显式调用operator=（s）来完成父类重载的调用。

当然，我们必须指明作用域才可以。其次1.不能自身给自身赋值 2.return *this保证连续赋值

	Student& operator=(const Student& s)
	{
		if (&s != this)
		{
			Person::operator=(s);
			_id = s._id;
		}

		cout << "Student& operator=(const Student& s)" << endl;

		return *this;
	}

析构函数

析构函数不允许额外调用基类的析构。因为派生类析构之后，会自动调用基类的析构。否则会造成资源的重复释放。

	~Student()
	{
		//Person::~Person();
		cout << "~Student()" << endl;
	}

原因：由于派生类可以访问基类成员，假设基类成员先析构，那么可能存在非法访问的问题。

构造：先父后子

析构：先子后父

基类占头尾

5.继承与友元

规则：友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

怎么理解呢？子承父业，子可以继承父亲的财产，但是父亲的朋友却不是你的朋友。除非进行声明。

class Student;
class Person
{
public:
 friend void Display(const Person& p, const Student& s);
protected:
 string _name; // 姓名
};
class Student : public Person
{
protected:
 int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
 cout << p._name << endl;
 cout << s._stuNum << endl;
}
void main()
{
 Person p;
 Student s;
 Display(p, s);
}

6. 继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子

类，都只有一个static成员实例 。

也就是说，派生类也会继承静态成员，但是只是继承的使用权（和继承的函数一样）

class Person
{
public :
 Person () {++ _count ;}
protected :
 string _name ; // 姓名
public :
 static int _count; // 统计人的个数。
};
int Person :: _count = 0;
class Student : public Person
{
protected :
 int _stuNum ; // 学号
};
class Graduate : public Student
{
protected :
 string _seminarCourse ; // 研究科目
};
void TestPerson()
{
 Student s1 ;
 Student s2 ;
 Student s3 ;
 Graduate s4 ;
 cout <<" 人数 :"<< Person ::_count << endl;
 Student ::_count = 0;
 cout <<" 人数 :"<< Person ::_count << endl;
}