作者：@小萌新
专栏：@C++进阶
作者简介：大二学生 希望能和大家一起进步！
本篇博客简介：简单介绍C++中继承的概念

继承的概念及定义

继承的概念

继承是一种面向对象编程的概念，它指的是一个类（称为子类）可以从另一个类（称为父类）中继承属性和方法。这意味着子类可以获得父类中定义的所有属性和方法，并且可以在不改变父类代码的情况下扩展或修改这些属性和方法。

那么这么做的优点是什么呢？

很显然的一点 可以增强代码的复用性 减少冗余代码

用代码来举个例子

class person
{
public:
	void Print()
	{
		cout << "name : " << _name << endl;
		cout << "age : " << _age << endl;
	}
protected:
	string _name = "zhangsan";
	int _age = 18;
};

// 学生类
class student :public person
{
public:
private:
	int _stuid;
};
// 教师类
class teacher :public person
{
public:
private:
	int _jobid;
};

从而达到一个这样子的效果

继承之后父类的所有成员 包括成员变量和方法 都会成为子类的一部分

继承的定义

定义格式

继承的定义方式如下

继承方式和访问限定符

我们都知道 访问限定符有三种

1. public访问
2. protected访问
3. private访问

继承的方式也有三种

1. public继承
2. protected继承
3. private继承

基类当中被不同访问限定符修饰的成员，以不同的继承方式继承到派生类当中后，该成员最终在派生类当中的访问方式将会发生变化。

如下图

实际上稍作观察之后我们就能发现

在子类中的访问访问方式遵循以下规则

1. 当父类的访问方式为protected或者public时 在子类中它会变成继承方式和父类访问方式中权限更小的值

什么意思呢？ 比如说父类的访问方式是public 子类使用protected继承 那么它在子类中的访问方式就变成protected了

如果父类的访问方式是protected 子类使用public继承 那么它在子类中的访问方式还是protected

2. 当父类的访问方式是privated时 不管子类使用何种继承方式 都是不可见的

那么不可见又是什么意思呢？

我们写出下面的一段代码

class person
{
public:
	void Print()
	{
		cout << "name : " << _name << endl;
		cout << "age : " << _age << endl;
	}
protected:
	string _name = "zhangsan";
	int _age = 18;
private:
	string _add = "chenghuadadao";
};

// 学生类
class student :public person
{
public:
	void testerr()
	{
		cout << this->_add << endl;
	}

我们可以发现 在学生类中 我们是无法访问父类中的_add的

事实上这里的编译器也直接给了我们红线报错

这里其实也从侧面说明了protected访问限定符为什么会出现

它的作用就是为了不想让类外部访问 而想让子类访问

但是 我们在实际写代码的过程中一般都是用public继承

这也是C++被人诟病的语法缺点之一 后续的python语言甚

至都没有继承方式这一说了

默认继承方式

这里我们不推荐使用默认继承方式 所以也就不多讲了

我们只需要知道两点

class的默认继承方式是 private

struct的默认继承方式是 public

基类和派生类的赋值转换

派生类对象可以赋值给基类的对象 基类的指针 基类的引用

在这个过程当中会发生基类和派生类对象之间的赋值转换

我们来看代码

class person
{
public:
	string _name;
	string _sex;
	int age;
};

class student : public person
{
private:
	int _stuid;
};

像上面的代码 我们写下下面这些操作全部是合法的

	student s;
	person p = s;
	person* ptr = &s;
	person& ref = s;

对于我们上面的操作 C++中给了一个比较专业的名词叫做切片

意思就是将子类中继承基类的那部分切出来 赋值给基类

对象赋值

指针赋值

引用赋值

那么这个时候我们再想一下 基类对象能否赋值给子类呢

我们写出上面的代码 结果发现报错了

其实想想也能明白 基类相对于子类来说会少一些东西

所以肯定是不能切片赋值的

但是子类的指针和引用可以通过强制类型转换的方式来赋值

代码和显示效果如下

    student* ptrs = (student *)&p;
	student& refs = (student&)p;

同样的 我们知道有这个方式存在就好 不建议使用！

继承中的作用域

接下来我们要学习的是C++继承中的又一大 缺陷（bushi） 特性之一

还是一样 我们先来看代码

//父类
class Person
{
protected:
	int _num = 111;
};
//子类
class Student : public Person
{
public:
	void fun()
	{
		cout << _num << endl;
	}
protected:
	int _num = 999;
};
int main()
{
	Student s;
	s.fun(); 
	return 0;
}

我们如果敲上上面的一段代码 并且调用fun函数的话 由于函数的局部性原理 我们会得到子类中的num值 如下图

这个时候如果我们想要访问父类中的num就需要使用域操作符

	void fun()
	{
		cout << Person::_num << endl;
	}

在继承体系中的基类和派生类都有独立的作用域。若子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。

需要注意的是，如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

还是拿上面的代码距离 我们给父类中加上一个fun函数

class Person
{
public:
	void fun()
	{
		cout << _num << endl;
	}

像这样 如果我们要调用父类里面的person函数只能加上一个域操作符 如下图

特别的 这两个函数不构成函数重载 因为构成函数重载的两个函数一定要在同一作用域

我们在真正写代码的时候应该避免重名的问题

派生类的默认成员函数

我们都知道 类有六大默认成员函数

下面我们看看派生类当中的默认成员函数，与普通类的默认成员函数的不同之处。

其实这里只要记住一点就好

凡是与基类相关的部分 都要调用基类的相关函数

此外还有以下三个注意点

1. 派生类和基类的赋值运算符重载函数因为函数名相同构成隐藏，因此在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。
2. 由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。
3. 在派生类的拷贝构造函数和operator=当中调用基类的拷贝构造函数和operator=的传参方式是一个切片行为，都是将派生类对象直接赋值给基类的引用。

继承与友元

这里还是记住一点就好 友元关系不可以继承

比如说

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

我们这里Display函数不能访问student

要想访问的话必须要在student中也声明友元

class Student : public Person
{
public:
	//声明Display是Student的友元
	friend void Display(const Person& p, const Student& s);
protected:
	int _id; //学号
};

总结

本篇博客主要介绍了继承的一些继承情况 明天看完所有课之后会在本篇博客后面更新继承的所有内容