继承的概念及定义

继承的概念

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

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

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

用代码来举个例子

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

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

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

继承的定义

定义格式

继承的定义方式如下

继承方式和访问限定符

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

public访问

protected访问

private访问

继承的方式也有三种

public继承

protected继承

private继承

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

如下图

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

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

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

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

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

当父类的访问方式是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函数只能加上一个域操作符如下图

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

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

派生类的默认成员函数

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

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

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

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

接下来我们来看代码

这是基类person的代码

//基类
class Person
{
public:
  //构造函数
  Person(const string& 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;
  }
private:
  string _name; //姓名
};

这是子类student的代码

//派生类
class Student : public Person
{
public:
  //构造函数
  Student(const string& name, int id)
  :Person(name) //调用基类的构造函数初始化基类的那一部分成员
  , _id(id) //初始化派生类的成员
  {
  cout << "Student()" << endl;
  }
  //拷贝构造函数
  Student(const Student& s)
  :Person(s) //调用基类的拷贝构造函数完成基类成员的拷贝构造
  , _id(s._id) //拷贝构造派生类的成员
  {
  cout << "Student(const Student& s)" << endl;
  }
  //赋值运算符重载函数
  Student& operator=(const Student& s)
  {
  cout << "Student& operator=(const Student& s)" << endl;
  if (this != &s)
  {
    Person::operator=(s); //调用基类的operator=完成基类成员的赋值
    _id = s._id; //完成派生类成员的赋值
  }
  return *this;
  }
  //析构函数
  ~Student()
  {
  cout << "~Student()" << endl;
  //派生类的析构函数会在被调用完成后自动调用基类的析构函数
  }
private:
  int _id; //学号
};

是不是发现完全符合我们上面的推论

这里有两个特殊结论

派生类对象初始化时，会先调用基类的构造函数再调用派生类的构造函数。

派生类对象在析构时，会先调用派生类的析构函数再调用基类的析构函数。

所以说我们在派生类的析构函数中不需要在显示调用基类的析构函数了

我们可以发现假设我们显示的调用基类的析构函数的话就会析构两次

这在一些情况（开辟释放内存）下会发生错误

此外还有以下三个注意点

派生类和基类的赋值运算符重载函数因为函数名相同构成隐藏，因此在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。

由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。

在派生类的拷贝构造函数和operator=当中调用基类的拷贝构造函数和operator=的传参方式是一个切片行为，都是将派生类对象直接赋值给基类的引用。

C++进阶继承（上）

继承的概念及定义