【C++干货基地】C++继承攻略：实现多态基础与代码复用的利器

🎬 鸽芷咕：个人主页
 🔥 个人专栏: 《C++干货基地》《粉丝福利》

⛺️生活的理想，就是为了理想的生活!

---

引入

  哈喽各位铁汁们好啊，我是博主鸽芷咕《C++干货基地》是由我的襄阳家乡的零食基地有感而发，不知道各位的城市有没有这种实惠又全面的零食基地呢？C++ 本身作为一门篇底层的一种语言，世面的免费课程大多都没有教明白。所以本篇专栏的内容全是干货让大家从底层了解C++，把更多的知识由抽象到简单通俗易懂。

一、继承的概念以及定义

1.1 继承的概念

面向对象的三大特性我相信大家都听说过 封装 继承 多态 封装我相信大家都不陌生前面我们对于迭代器，以及反向迭代器都是对代码的一种封装那继承是什么呢？

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

比如说以下这个设计就需要我们用到继承的理念

• 这里就是继承的概念这个这个类中不管是 学生还是保安 教室 都是人的一种当我们设计这样的类时，就需要用到继承的概念。

1.2 继承的定义

派生类 继承方式 基类
class Student : public Person

class Person
{
public:
 void Print()
 {
 cout << "name:" << _name << endl;
 cout << "age:" << _age << endl;
 }
protected:
 string _name = "peter"; // 姓名
 int _age = 18;  // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分
class Student : public Person
{
protected:
 int _stuid; // 学号
};

2.3 继承的限定

继承的访问限定符

继承基类成员访问方式的变化

类成员/继承方式	public继承	private继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私
   有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面
   都不能去访问它。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在
   派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他
   成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过
   最好显示的写出继承方式。
5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡
   使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里
   面使用，实际中扩展维护性不强

二、基类和派生类对象赋值转换

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

2.1 切片与切割

• 基类对象不能赋值给派生类对象。
• 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。
• 但是必须是基类的指针是指向派生类对象时才是安全的

派生类可以赋值给基类

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;
    
    // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    pp = &sobj
    Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
    ps1->_No = 10;
    
    pp = &pobj;
 Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问
题
    ps2->_No = 10;
}

这里我们就可以看到派生类时可以直接复制给基类成员的他们中间的操作类似切片所以，被叫为切片/切割

2.2 继承中的作用域（隐藏和重定义）

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

• 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，
  也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
• 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
• 注意在实际中在继承体系里面最好不要定义同名的成员

代码演示

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Student : public Person
{
public:
	void func()
	{
		cout << _name << endl;
		Print();
	}
protected:
	int _stuid; // 学号
};
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();
};

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

三、派生类中默认成员函数的行为

3.1 派生类的构造函数

必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

class Person
{
public:
	Person(const char* name)
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	// 父类+自己，父类的调用父类构造函数初始化（复用）
	Student(int num, const char* str, const char* name)
		:Person(name)
		, _num(num)
		, _str(str)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s)
		, _num(s._num)
		, _str(s._str)
	{}

protected:
	int _num;	 //学号
	string _str;
	/ 父类成员，当成一个整体的一个自定义类型成员
	// 子类的成员(跟以前一样)
	// a、内置类型
	// b、自定义类型
};

int main()
{
	Student s1(1, "xxxx", "张三");
}

3.2 派生类的拷贝构造函数

必须调用基类的拷贝构造完成基类的拷贝初始化。

• 但是我们没写拷贝构造，派生类会生成默认拷贝构造
• 其中继承的父类，会默认调用自己的拷贝构造
• 自己成员调用默认拷贝构造

🔥 :Person(s)//这里有隐式类型转换 （切片）

// s2(s1)
	Student(const Student& s)
		:Person(s)//这里有隐式类型转换 （切片）
		,_num(s._num)
		,_str(s._str)
	{}

Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
			_str = s._str;
		}
		return *this;
	}

3.3 派生类的operator=

必须要调用基类的operator=完成基类的复制

• 当然默认生成的赋值: 对内置类型浅拷贝
• 为自定义类型调用它的拷贝构造

🔥 Person::operator=(s); 要注意这里一定要显示调用基类operator=

• 前面的作用域知识点

Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//要注意这里一定要显示调用基类operator=
			_num = s._num;       // 否者子类和父类构成隐藏，导致无限递归
			_str = s._str;
		}
		return *this;
	}

3.4 派生类的析构函数

会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序

🔥 因为后续多态的需要，析构函数名字会被统一处理成destructor

• 如果我们手动调用父类的析构函数，那么子类的析构函数结束后会再次调用一次到处继承的父类被调用了俩次析构函数

// 子类的析构也会隐藏父类
	// 因为后续多态的需要，析构函数名字会被统一处理成destructor
	~Student()
	{
		// 显示写无法先子后父
		//Person::~Person();

		cout << _name << endl;
		cout << "~Student()" << endl;

		// 注意，为了析构顺序是先子后父，子类析构函数结束后会自动调用父类析构
	}

🔥 如果你先把父类析构那么在子类的析构函数还能访问原来析构过的父类成员，这就会构成野指针的情况cout << _name << endl;

• 所以我们在使用派生类时
• 构造函数要 先构造父类在构造子类
• 析构函数要 先析构子类在析构父类

📝文章结语：

☁️ 看到这里了还不给博主扣个：
⛳️ 点赞🍹收藏 ⭐️ 关注！
💛 💙 💜 ❤️ 💚💓 💗 💕 💞 💘 💖
拜托拜托这个真的很重要！
你们的点赞就是博主更新最大的动力！