🌈欢迎来到C++专栏~~继承
- (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort
- 目前状态：大三非科班啃C++中
- 🌍博客主页：张小姐的猫~江湖背景
- 快上车🚘，握好方向盘跟我有一起打天下嘞！
- 送给自己的一句鸡汤🤔：
- 🔥真正的大师永远怀着一颗学徒的心
- 作者水平很有限，如果发现错误，可在评论区指正，感谢🙏
- 🎉🎉欢迎持续关注！
继承
- 🌈欢迎来到C++专栏~~继承
- 0. 继承的定义
- 一. 继承的规则
- 1️⃣ 继承的格式
- 2️⃣ 访问限定符 & 继承方式
- 3️⃣ 继承父类的成员访问方式变化
- 二. 赋值兼容规则 - 切片
- 三. 继承中的作用域 - 隐藏
- 四. 派生类的默认成员函数
- 五. 继承和友元
- 六. 继承和静态成员
- 七. 菱形继承 & 菱形虚拟继承
- 🌈菱形继承
- 🌈菱形虚拟继承
- 🌈菱形虚拟继承的原理
- 十. 常见面试题
- 1️⃣如何定义一个不能被继承的类？
- 2️⃣ 多继承中指针偏移问题
- 📢写在最后
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️⃣ 继承父类的成员访问方式变化
-
🥑 父类的
private成员在子类中都是不可见的。不可见是指父类的私有成员被子类继承了，但是在语法上限制子类对象在类内&类外都不可以访问。这里需要区分private和不可见，区别主要在于在类里面是否可以访问，private类内可以类外不可；不可见类内外都不可（相当于隐身了）。 -
🥗基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的
-
🌏实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 ==
Min(成员在基类的访问限定符，继承方 式)，public > protected > private。 -
使用关键字
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=？同上
- 父类继承下来的：调用父类的默认构造&析构
- 自己的：和普通类一样(内置类型不处理；自定义类型调用自己的默认构造&析构)
🥑大结论：父类成员调用父类的来处理，自己成员跟类和对象一样处理
💦那什么时候需要我们自己手动写？
- 父类没有默认构造函数，需要我们自己写，显式的调用构造。不能自己处理
- 析构函数呢？如果子类有资源需要释放，就需要自己写析构。父类的不用管，会调用父类的完成(父类就那一个析构，不存在调不到问题)
- 如果子类存在深拷贝问题，就需要自己实现拷贝构造和赋值重载来深拷贝
💢如果要自己写，要怎么样写呢？父类成员调用父类对应的构造、拷贝构造、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
B c = d;
B* pb = &d;
注意：有公共祖先类就会构成菱形继承，那么virtual加在哪里呢？
注意虚拟继承是放在腰上，要解决的是A 的二义性和数据冗余问题
十. 常见面试题
1️⃣如何定义一个不能被继承的类？
- 父类构造函数私有 —— 子类是不可见；子类对象实例化，无法调用构造函数
- 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
📢写在最后
羊了个羊
![[Android移动安全渗透基础教程] 易受攻击的移动应用程序](https://img-blog.csdnimg.cn/f56539491100458584f43795e10a3427.png)
![[附源码]Nodejs计算机毕业设计基于的扶贫产品展销平台Express(程序+LW)](https://img-blog.csdnimg.cn/123f23c501a44228b8ff1ac7fccbb97d.png)
