【C++】继承（万字详解，2024年我们程序员该如何进阶和规划

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

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

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

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

#include <iostream>
#include <string>

using namespace std;

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

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

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

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

一. 继承的规则

1️⃣ 继承的格式

下面我们看到Person是父类，也称作基类；Student是子类，也称作派生类

2️⃣ 访问限定符 & 继承方式

类和对象中，protected和private没有太大的区别，它们的区别体现在继承中：在这一层没有区别，下一层private无法再继承下去(事实上，在继承体系中，很少用private)。

这样组合下来就有3*3种继承情况：

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

这里有个小技巧来记忆，并不复杂，接着往下看吧

3️⃣ 继承父类的成员访问方式变化

1. 🥑 父类的private成员在子类中都是不可见的。不可见是指父类的私有成员被子类继承了，但是在语法上限制子类对象在类内&类外都不可以访问。这里需要区分private和不可见，区别主要在于在类里面是否可以访问，private类内可以类外不可；不可见类内外都不可（相当于隐身了）。
2. 🥗基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的
3. 🌏实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方 式)，public > protected > private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

🎃可见C++作为第一个吃螃蟹的人，此处设计过于复杂。实际上一般使用都是public继承，几乎很少使用protected/private继承(也不推荐使用保护和私有继承，因为保护和私有继承下来的成员只能子类的类内部使用，扩展维护性不强)

💥总结：常见的大多是

• 父类成员：公有和保护
• 子类继承方式：公有继承

二. 赋值兼容规则 - 切片

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

上代码理解：

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;//此处就能发现不是隐式类型转换
}

1️⃣此处是特殊支持情况（语法天生支持的），虽然是不同类型，但是不是隐式类型转换；类型转换中间会产生临时变量，临时变量具有常属性，必须加const，这儿不加也不报错

	Student sobj;
	Person pobj;
	//1.父类 = 子类
	Person = sobj;
	Person\* pp = &sobj;
	Person& rp = sobj;

2️⃣父类对象不能赋值给子类对象：因为父类的数据比较少，那少的_NO找谁要？

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

 Student sobj ;
 Person pobj;
// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
pp = &sobj
Student \* ps1 = (Student\*)pp; // 这种情况转换时可以的。
ps1->_No = 10;

pp = &pobj;
Student\* ps2 = (Student\*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问
题
ps2->_No = 10;

三. 继承中的作用域 - 隐藏

🌈子类和父类出现同名成员，称为隐藏/重定义（只要函数名相同就构成隐藏）

• 在继承体系中基类和派生类都有独立的作用域
• 若子类与父类有同名成员，由局部优先原则，子类会屏蔽父类，优先访问自己类中的成员；若想访问父类成员，需要指定作用域（基类::基类成员 显示访问）。这种情况就叫隐藏/重定义。

注：在继承体系中，最好不要定义同名的成员（函数+变量）

#include<iostream>
#include<string>

using namespace std;

// Student的\_num和Person的\_num构成隐藏关系(这样代码虽然能跑，但是非常容易混淆)
class Person
{
protected:
	string _name = "Scort"; // 姓名
	int _num = 11111; //身份证号
};

class Student : public Person
{
public:
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << "学号:" << _num << endl; //就近原则
		cout << "身份证号:" << Person::_num << endl; //需要指定作用域
	}
protected:
	int _num = 999; //学号
};

int main()
{
	Student s1;
	s1.Print();
	return 0;
}

上手一道小题目：

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

以上程序的两个func函数的关系是什么？

a. A、B的func构成函数重载
b. 编译报错
c. 运行报错    
d. A、B的func构成函数隐藏

这里不可能构成重载！因为函数重载要求在同一个作用域；那么便是函数隐藏，选d；编译报错，因为被隐藏了根本调不到，需要指定作用域b.A::func();.我们总结得出———

🎨对于成员函数的隐藏，只要函数名相同就构成隐藏，参数随意

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

🎨关于子类的默认成员函数，我们一共要探讨两个问题 ——

• 派生类的4个重点默认成员函数，我们不写，编译器默认会做什么？
• 如果我们要写，要写些什么？什么情况下必须自己写？

#include<iostream>
#include<string>

using namespace std;

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; //姓名
};

class Student : public Person
{
public:
	//啥都不写
protected:
	string _id; //学号
};

int main()
{
	Student s1;
    Student s2(s1);
	return 0;
}

由结果可以看出——
⭐️1.1 我们不写默认生成的子类的构造&析构？

• 父类继承下来的：必须调用父类的默认构造&析构
• 自己的：跟类和对象一样(内置类型进行值拷贝；自定义类型调用自己的默认构造&析构)

注：父类成员不能在子类通过初始化列表进行初始化，我们可以理解成子类会把父类成员当成一个整体，父类扎堆去调用父类的，子类调子类的

那拷贝构造和赋值呢？

⭐️1.2 我们不写默认生成的子类的拷贝构造&赋值重载operator=？同上

• 父类继承下来的：调用父类的默认构造&析构
• 自己的：和普通类一样(内置类型不处理；自定义类型调用自己的默认构造&析构)

🥑大结论：父类成员调用父类的来处理，自己成员跟类和对象一样处理

💦那什么时候需要我们自己手动写？

1. 父类没有默认构造函数，需要我们自己写，显式的调用构造。不能自己处理
2. 析构函数呢？如果子类有资源需要释放，就需要自己写析构。父类的不用管，会调用父类的完成(父类就那一个析构，不存在调不到问题)
3. 如果子类存在深拷贝问题，就需要自己实现拷贝构造和赋值重载来深拷贝

💢如果要自己写，要怎么样写呢？父类成员调用父类对应的构造、拷贝构造、operator=和析构来处理；自己的成员按照普通类来处理：该浅拷贝的浅拷贝，该深拷的深拷贝

#include<iostream>
#include<string>

using namespace std;

class Person
{
public:
	//Person(const char\* name = "peter")
	Person(const char\* name ) //没有默认构造函数
		: \_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; //姓名
};

class Student : public Person
{
public:
	Student(const char\* name, int num)
		//:\_name(name)
		:Person(name) //像调用匿名对象一样
		, \_num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s)//显示调用了父类的拷贝 —— 也用了切片，传过去的是子类的部分切给父类的那部分的指针
		,\_num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	// s3 = s1
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			//显示调用父类的赋值，需要指定作用域，因为同名函数隐藏了父类，不然就会不断调用子类的，导致stack overflow
			Person::operator=(s);//引用切片 
			_num = s._num;
		}

		cout << "Student operator=(const Student& p)" << endl;
		return \*this;
	}
	
	~Student()
	{
		//Person::~Person();
		cout << "~Student()" << endl;
		// ...处理子类自己的
	}
protected:
	int _num; //学号
};

int main()
{
	Student s1("张三", 2);
	Student s2(s1);
	Student s3("李四", 3);
	s1 = s3;
	return 0;
}

关于析构函数~最为特别

🌏析构时候发现，报错了而且报错很奇怪，其实是因为析构函数的名字会被统一处理成destructor()；那么子类和父类的析构函数构成隐藏，需要指定作用域（多态的需要，下一篇详解）

进行调整后又发现：多析构了一次父类

🔥难道说不需要我们显式调用父类的析构函数？没错！子类析构函数结束时，会自动调用父类的析构函数，这样才能保证先析构子类成员，后析构父类成员（自己写就无法保证这个顺序了）

析构和析构顺序：

因此实现子类析构函数时，不需要显式调用父类的析构函数

五. 继承和友元

友元关系不能继承。父类的友元，不是子类的友元

class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};
class Student : public Person
{
	//friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;//Display不是子类的友元，所以报错
}
void main()
{
	Person p;
	Student s;
	Display(p, s);
}

想访问的话，就把Display搞成子类的友元

六. 继承和静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个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; // 学号
};

int main()
{
	Person p;
	Student S;

	p._name = "张三";
	cout << S._name << endl;

	cout << Student::_count << endl;
	++Person::_count;
	cout << Student::_count << endl;
	cout << &Person::_count << endl;//地址
	cout << &Student::_count << endl;

	return 0;
}

运行结果——

七. 菱形继承 & 菱形虚拟继承

🌈菱形继承

💠单继承：一个子类只有一个直接父亲

💠 多继承：一个子类有两个及两个以上的直接父亲

多继承看起来合理，其实就是坑，C++作为"第一个吃螃蟹的人"（Java后面的语言就避开了），带来了菱形继承，也就说助教对象中有两份Person，会有数据冗余和二义性的问题

二义性可以通过指定作用域勉强搞定

#include<string>

using namespace std;

class Person
{
public:
	string _name; //姓名
};

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

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

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; //主修课程
};

int main()
{
	//二义性：对\_name的访问不明确
	Assistant a;
	//a.\_name = "peter"; //nope~ 错误示范，请勿模仿


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

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/7dfef6066657683a10e9907aa2726740.png)

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

mespace std;

class Person
{
public:
	string _name; //姓名
};

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

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

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; //主修课程
};

int main()
{
	//二义性：对\_name的访问不明确
	Assistant a;
	//a.\_name = "peter"; //nope~ 错误示范，请勿模仿


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

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
[外链图片转存中...(img-REx2qcQH-1713338768423)]

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