【C++】继承（万字详解） —— 切片 | 隐藏 | 子类的默认成员函数 | 菱形继承

🌈欢迎来到C++专栏~~继承

---

• (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort
• 目前状态：大三非科班啃C++中
• 🌍博客主页：张小姐的猫~江湖背景
• 快上车🚘，握好方向盘跟我有一起打天下嘞！
• 送给自己的一句鸡汤🤔：
• 🔥真正的大师永远怀着一颗学徒的心
• 作者水平很有限，如果发现错误，可在评论区指正，感谢🙏
• 🎉🎉欢迎持续关注！
  

0. 继承的定义

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

以前我们接触的复用都是函数复用，继承是类设计层次的复用

在代码层面上理解：

#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~ 错误示范，请勿模仿

	//需要显示指定访问哪个父类的成员
	a.Student::_name = "蛋哥";
	a.Teacher::_name = "杭哥"; 
	return 0;
}

那么数据冗余咋办呢？

🌈菱形虚拟继承

注意是在腰上添加virtual，不要乱用

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

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

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

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

int main()
{
	Assistant a;

	//无需指定，访问的是同一个
	a._name = "蛋哥";
	a.Student::_name = "杭哥";
	a.Person::_name = "基哥";
	return 0;
}

🌈菱形虚拟继承的原理

为了研究原理：虚继承究竟是如何解决数据冗余的

class A
{
public:
	int _a;
};

class B : public A
//class B : virtual public A 
{
public:
	int _b;
};

class C : public A
//class C : virtual public A 
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	
	return 0;
}

先来实验不采用虚拟继承时，是有数据冗余 & 二义性问题的(且先继承的在前，后继承的在后) ——

💦 当观察虚拟继承时，可以观察到， A成员的确只存储了一份，在对象的最底下——

此处我们发现：虚继承并没有节省空间，但是我们转换思路，a是一个int a[10000]数组，再那就节省了4万字节

但是B和C中是什么？推测是地址，众所周知，当前机器采取的是小端存储(低位存低地址，高位存高地址)，我们再打开内存窗口来看这地址存的什么 ——

D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A(虚基类)呢？就是通过了B和C的两个指针虚基表指针)，指向的虚基表(找虚基类的表)。虚基表中存的偏移量，通过偏移量可以找到下面的A

Person关系菱形虚拟继承的原理 ——

A一般叫做虚基类，在D中，A放到一个公共位置，有时B需要找A、C需要找A，就要通过虚基表中的偏移量来计算。那为什么要找呢？考虑以下场景

    //此时的B对象一部分是继承A的，一部分是自己的
    B d;
    B* Pb = &d; //切片，要找_a
    
    C c = d;
	C* pb = &d;

当我们求得bb的大小时候发现 ——

	B bb;
	cout << sizeof(bb) << endl;
	bb._a = 1;
	bb._b = 2;

同时我们发现这种存储方式是十分巧妙的

void func(B* ptr)
{
	cout << ptr ->_a << endl;
}

func(&d);
func(&bb);

此处不知道ptr是指向父类还是子类的_a，但是父类和子类的存储结构都是保持一致的，_a都是放在最下面的位置。

注意：有公共祖先类就会构成菱形继承，那么virtual加在哪里呢？

注意虚拟继承是放在腰上，要解决的是A 的二义性和数据冗余问题

八. 总结

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java

💞继承和组合

继承和组合都是一种复用，只不过访问的方式有所不同，组合只能访问公有

   // Car和BMW Car构成is-a的关系 
   //继承—— 白箱复用(white-box reuse)
   class Car{
   protected:
   string _colour = "白色"; // 颜色
   string _num = "粤A0DU95"; // 车牌号
   };
   
   class BMW : public Car{
   public:
   void Drive() {cout << "好开-操控" << endl;}
   };

   // Tire和Car构成has-a的关系(轮胎和车)
   //组合 - 黑箱复用(black-box reuse)
   class Tire{
   protected:
       string _brand = "Michelin";  // 品牌
       size_t _size = 17;         // 尺寸
   };
   
   class Car{
   protected:
   string _colour = "白色"; // 颜色
   string _num = "粤A0DU95"; // 车牌号
    Tire _t; // 轮胎
   };  

• public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象
• 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象
• 如果既符合继承和组合，优先使用对象组合，而不是类继承
• 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高
• 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装
• 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合

另外我们希望，模块之间的关系最好是 低耦合高内聚，方便维护。继承(A和B)，耦合度高，依赖性强，任意一个成员的改变都会对我有影响；组合(C和D)，耦合度低，依赖关系较弱 （继承就是跟团游 ，组合就是自由行）

结论：完全符合is-a，就用继承；完全符合has-a，就用组合；既是is-a，又是has-a，优先用组合而不是继承

九. 常见面试题

1️⃣如何定义一个不能被继承的类？

1. 父类构造函数私有 —— 子类是不可见；子类对象实例化，无法调用构造函数
2. C++11 final关键字

//方法一：父类构造函数私有
class A 
{
private:
	A()
	{}
protected:
	int _a;
};

class B : public A
{

};

int main()
{
	B bb;
	return 0;
}

方法二：final关键字

2️⃣ 多继承中指针偏移问题

下面说法正确的是( )

class Base1 {  public:  int _b1; };
class Base2 {  public:  int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main(){
	 Derive d;
	 Base1* p1 = &d;
 	 Base2* p2 = &d;
 	 Derive* p3 = &d;
 	 return 0;
}

A：p1 == p2 == p3
B：p1 < p2 < p3
C：p1 == p3 != p2
D：p1 != p2 != p3
E：编译报错
F：运行报错

答案选C

📢写在最后

羊了个羊