C C++最新【C++】继承，终局之战

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

6.继承与静态成员

7.复杂的菱形继承与虚拟继承

虚拟继承原理（剖析底层）

（1）采用普通继承下的内存分布

（2）采用虚拟继承下的内存分布

8.继承的总结和反思

---

前言

本篇文章主要讲解『 C++继承』的相关内容。

---

欢迎大家📂收藏📂以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。

=========================================================================

**GITEE相关代码：**🌟fanfei_c的仓库🌟

=========================================================================

---

1.继承的概念

1.1定义

为了提高代码的复用性，C++设计出了继承这一概念。

继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持『 原有类特性的基础』上进行『 扩展』，『 增加』功能。这样产生的新类，称『 派生类』（或『 子类』），被继承的类称『 基类』（或『 父类』）。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

之前接触的复用都是函数复用，继承是类设计层次的复用。

---

1.2格式

例如：

父类Person：

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

子类Student：

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

子类Teacher：

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

按照继承的格式我们得知，Student与Teacher『 public继承』 了Person。

int main()
{
	Student s;
	Teacher t;
	s.Print();
	t.Print();
	return 0;
}

我们可以从打印结果了解到，子类继承父类的大概意思就是子类可以继承得到父类的成员，可以理解为『 继承家产』。

那么子类可以继承得到父类的全部成员么？

答案是否定的！

这就要我们剖析一下继承方式了：

继承方式：

• public继承
• protected继承
• private继承

类成员/继承方式	public继承	protected继承	private继承
父类的public成员	子类的public成员	子类的protected成员	子类的private成员
父类的protected成员	子类的protected成员	子类的protected成员	子类的private成员
父类的private成员	在子类中不可见	在子类中不可见	在子类中不可见

上面这张表不需要死记硬背，我们来『 理解着记忆』：

①父类的private成员，子类会继承但『 不可见』（不可见不是不存在，而是存在，但不能使用）。

②若父类想要子类能访问到他的成员，父类中的成员『 至少』要定义为protected。

③父类的『 public成员』和『 protected成员』在子类中的访问方式为Min(父类中的访问限定符，继承方式)。

public > protected > private

④若不指定继承方式，class默认为private，struct默认为public继承。但最好显示的写出。

⑤一般都使用public继承。

---

2.父类和子类对象的赋值转换

（1）『 子类对象』可以赋值给 『 父类的对象』/ 『 父类的指针』/ 『 父类的引用』。这里有个形象的说法叫『 切片』或者『 切割』。寓意把子类中父类那部分切来赋值过去。

（2）『 父类对象』不能赋值给子类对象。

（3）父类的指针或者引用可以通过强制类型转换赋值给子类的指针或者引用。但是必须是父类的指针是指向子类对象时才是安全的。这里父类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：这个我们后面再讲解，这里先了解一下）

例如：

class Person
{
protected:
	string _name;//姓名string_sex;//性别
	int _age;//年龄
};
class Student : public Person
{
public:
	int _No;//学号
};
void Test()
{
	Student sobj;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person pobj = sobj; 
	Person* pp = &sobj; 
	Person& rp = sobj;
	//2.基类对象不能赋值给派生类对象
	sobj = pobj;//err
	// （略）3.基类的指针可以通过强制类型转换赋值给派生类的指针
	pp = &sobj;
	Student * ps1 = (Student*)pp;//这种情况转换时可以的。
	ps1->_No = 10;
	pp = &pobj;
	Student* ps2 = (Student*)pp;//这种情况转换时虽然可以，但是会存在越界访问的问题
	ps2->_No = 10;
}

---

3.继承的作用域

1. 在继承体系中父类和子类都有『 独立』的作用域。
2. 子类和父类中有同名成员：子类成员将『 屏蔽』父类对同名成员的直接访问，这种情况叫『 隐藏』，也叫重定义。（在子类成员函数中，可以『 使用父类::父类成员显示访问』）
3. 需要注意的是如果是成员函数的隐藏，只需要『 函数名相同』就构成隐藏，即『 不考虑』返回值和参数。
4. 注意在实际中在继承体系里面『 最好不要定义同名的成员』。

这里有非常容易混淆的知识点：『 重载』和『 隐藏』

例如：

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;
	}
};

• B中的fun和A中的fun『 不是构成重载』，因为不是在同一作用域！
• B中的fun和A中的fun『 构成隐藏』，成员函数满足函数名相同就构成隐藏。

---

4.子类的默认成员函数

4.1构造函数

先父后子：先调用父类的构造函数，再调用子类的构造函数。

即构造子类，会先构造父类，再构造子类

例如：

class Person {
public:
	Person(string name = "小樊")
		:_name(name)
	{
		cout << name << endl;
	}
protected:
	string _name;
};
class student :public Person
{
public:
	student(string name, int age)
		:_age(age)
	{
		cout << name << endl << age << endl;
	}
protected:
	int _age;
};

int main()
{
	student st("小飞", 18);构造子类，会先调用父类然后再调用子类
	return 0;
}

该样例中，父类构造给了缺省参数，即父类有默认构造，所以子类并没有显示调用父类的构造函数，而是编译器自动调用，如果这里没给缺省值，那么就需要你在子类中给定父类构造的参数。

如：

human(string name)//不给缺省参数，相当于父类无默认构造
		:_name(name)
{
    cout << name << endl;
}
//所以这种情况必须在子类中给父类构造赋值，否则就会报错
student(string name,int age)
		:_age(age)
		, human(name)//显示调用父类构造方式『 记忆』
//新增，子类以自己的name给父类构造中的name赋值
//age和name的顺序随意变动，初始化顺序仅与声明顺序有关

虽然上述代码子类构造的初始化列表中， _age仿佛先于human初始化，但是别忘了：初始化顺序仅与声明顺序有关，与初始化列表顺序无关！！！

所以这里一定是『 先父后子』。

---

4.2析构函数

先子后父：先调用子类的析构函数，再调用父类的析构函数。

例如：

class Person {
public:
	Person(string name = "小樊")
		:_name(name)
	{}
	~Person()
	{
		cout << "调用父类析构" << endl;
	}
protected:
	string _name;
};
class student :public Person
{
public:
	student(string name, int age)
		:_age(age)
	{}
	~student()
	{
		cout << "调用子类析构" << endl;
	}
protected:
	int _age;
};

int main()
{
	student st("小飞", 18);
	return 0;
}

也就是说，子类析构时会自动调用父类析构。

所以我们就『 不需要自己再去调用父类析构』了，即**『 不要在子类中调用父类析构』**，否则会出现『 析构两次』的情况。

---

4.3拷贝构造

先父后子：先调用父类的拷贝构造，再调用子类的拷贝构造。

class Person {
public:
	Person(string name = "小樊")
		:_name(name)
	{}
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "调用父类拷贝构造" << endl;
	}
protected:
	string _name;
};
class student :public Person
{
public:
	student(string name, int age)
		:_age(age)
	{}
	student(const student& s)
		:Person(s)//切片，将子类中父类的部分切割赋值给父类
		, _age(s._age)
	{
		cout << "调用子类拷贝构造" << endl;
	}

protected:
	int _age;
};

int main()
{
	student st("小飞", 18);
	student st2(st);
	return 0;
}

注意：代码中注释部分，当需要独立实现子类的拷贝构造『 不满足默认生成的』时，需要在初始化列表中调用父类的拷贝构造，这里直接将子类对象的引用传递给父类即可，上面讲过『 父类和子类对象的赋值转换（切片）』。

---

4.4赋值重载

子类的operator=必须要调用父类的operator=完成父类的赋值。

class Person {
public:
	Person(string name = "小樊")
		:_name(name)
	{}
	Person& operator=(const Person& p)
	{
		cout << "调用父类赋值重载" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}
protected:
	string _name;
};
class student :public Person
{
public:
	student(string name, int age)
		:_age(age)
	{}
	student& operator=(const student& s)
	{
		cout << "调用子类赋值重载" << endl;
		
		if (this != &s)
		{
			Person::operator=(s);//必须指定，因为父子类中的operator=构成隐藏关系
			_age = s._age;
		}
		
		return *this;
	}

protected:
	int _age;
};

int main()
{
	student st("小飞", 18);
	student st2("小凡",20);
	st = st2;
	return 0;
}

注意：代码中注释部分，必须要指定父子类的operator=，因为父子类中都有operator=，如果不指定，会构成隐藏关系，子类一直调用子类的operator=构成死循环。

---

总结：谁干谁的活，子类不能替父类完成默认成员函数干的活，必须调用父类的默认成员函数。

---

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;
}
int main()
{
	Person p; 
	student s; 
	Display(p,s);
}

当然如果你想让父亲的朋友成为你的朋友，你得声明。

class student : public Person
{
public:
	friend void Display(const Person& p, const student& s);
protected:
	int _stuNum;//学号
};

---

6.继承与静态成员

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

ndl;
}
int main()
{
Person p;
student s;
Display(p,s);
}

![](https://i-blog.csdnimg.cn/blog_migrate/1ed2ad8c05d835fd7bd10ecd815b3ab3.png)


当然如果你想让父亲的朋友成为你的朋友，你得声明。

class student : public Person
{
public:
friend void Display(const Person& p, const student& s);
protected:
int _stuNum;//学号
};

---


## 6.继承与静态成员



[外链图片转存中...(img-n3BSt5l6-1715723614221)]
[外链图片转存中...(img-QalESC9n-1715723614222)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.youkuaiyun.com/topics/618668825)**