【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种继承情况：

这里有个小技巧来记忆，并不复杂，接着往下看吧

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++】继承（万字详解） —— 切片 | 隐藏 | 子类的默认成员函数 | 菱形继承(上）

0. 继承的定义

一. 继承的规则

二. 赋值兼容规则 - 切片

三. 继承中的作用域 - 隐藏

五. 继承和友元

六. 继承和静态成员

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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

0. 继承的定义

一. 继承的规则

二. 赋值兼容规则 - 切片

三. 继承中的作用域 - 隐藏

五. 继承和友元

六. 继承和静态成员

热门文章

最新文章

相关课程

相关电子书