0
0

【C++】—— 继承（上）

【C++】—— 继承（上）

1 继承的概念与定义

1.1 继承的概念

  继承（inheritance）机制是面向对象设计使代码可以复用的最重要的手段，它允许我们在保存原有特性的基础上进行扩展，增加方法（成员函数）和属性（成员变量），这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复用。

  下面我们通过一个例子来初步感受一下继承：

  1. classStudent{public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证voididentity(){// ...}// 学习voidstudy(){// ...}protected:
  2.     string _name ="peter";// 姓名
  3.     string _address;// 地址
  4.     string _tel;// 电话int _age =18;// 年龄int _stuid;// 学号};classTeacher{public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证voididentity(){// ...}// 授课voidteaching(){//...}protected:
  5.     string _name ="张三";// 姓名int _age =18;// 年龄
  6.     string _address;// 地址
  7.     string _tel;// 电话
  8.     string _title;// 职称};

  上面，我们看到没有继承之前我们设计了两个类 

  1. Student

和 

  1. Teacher

， 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student 和  
  27.  
  28.   
  29.    
  30.    
  31.      T 
  32.     
  33.    
  34.      e 
  35.     
  36.    
  37.      a 
  38.     
  39.    
  40.      c 
  41.     
  42.    
  43.      h 
  44.     
  45.    
  46.      e 
  47.     
  48.    
  49.      r 
  50.     
  51.    
  52.   
  53.     Teacher 
  54.    
  55.   
  56. Teacher**都有** 姓名 / 地址 / 电话 / 年龄 等成员变量，**都有** 
  57.  
  58.   
  59.    
  60.    
  61.      i 
  62.     
  63.    
  64.      d 
  65.     
  66.    
  67.      e 
  68.     
  69.    
  70.      n 
  71.     
  72.    
  73.      t 
  74.     
  75.    
  76.      i 
  77.     
  78.    
  79.      t 
  80.     
  81.    
  82.      y 
  83.     
  84.    
  85.   
  86.     identity 
  87.    
  88.   
  89. identity ⾝份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有⼀些**独有**的成员变量和函数，比如老师独有成员变量是职称，学生的独有成员变量是学号；学⽣的独有成员函数是学习，⽼师的独有成员函数是授课。

  既然 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student 和  
  27.  
  28.   
  29.    
  30.    
  31.      T 
  32.     
  33.    
  34.      e 
  35.     
  36.    
  37.      a 
  38.     
  39.    
  40.      c 
  41.     
  42.    
  43.      h 
  44.     
  45.    
  46.      e 
  47.     
  48.    
  49.      r 
  50.     
  51.    
  52.   
  53.     Teacher 
  54.    
  55.   
  56. Teacher 两个类的设计有些冗余，那我们能不能把公共的信息提取出来呢？

  下面我们公共的成员都放到 Person 中，Student 和 Teacher 都继承 Person，就可以复⽤这些成员，就不需要重复定义了，省去了很多麻烦。

  1. classPerson{public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证voididentity(){
  2.         cout <<"void identity()"<< _name << endl;}protected:
  3.     string _name ="张三";// 姓名
  4.     string _address;// 地址
  5.     string _tel;// 电话int _age =18;// 年龄};classStuden:publicPerson{public:// 学习voidstudy(){// ...}protected:int _stuid;// 学号};classTeacher:publicPerson{public:// 授课voidteaching(){//...}protected:
  6.     string title;//职称};

  虽然 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student类 的成员变量看起来只有
  1. int _stuid;

，但它继承了Person类，它还有

  1. string _name

、

  1. string _address;

等等成员变量。成员函数也不止

  1. void study()

，还有

  1. void identity()

1.2 继承定义

1.2.1 定义格式

  下面我们看到 

  1. Person

是父类，也称作基类。

  1. Student

是子类，也称作派生类。（因为翻译的原因，所以既叫父类/子类，也叫基类/派生类）

在这里插入图片描述

  继承方式与访问限定符一样，都有三个：公有、保护、私有

在这里插入图片描述

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

类成员/继承方式 

  1.         p 
  2.        
  3.       
  4.         u 
  5.        
  6.       
  7.         b 
  8.        
  9.       
  10.         l 
  11.        
  12.       
  13.         i 
  14.        
  15.       
  16.         c 
  17.        
  18.       
  19.      
  20.        public 
  21.       
  22.      
  23.    public 继承 
  24.     
  25.      
  26.       
  27.       
  28.         p 
  29.        
  30.       
  31.         r 
  32.        
  33.       
  34.         o 
  35.        
  36.       
  37.         t 
  38.        
  39.       
  40.         e 
  41.        
  42.       
  43.         c 
  44.        
  45.       
  46.         t 
  47.        
  48.       
  49.         e 
  50.        
  51.       
  52.         d 
  53.        
  54.       
  55.      
  56.        protected 
  57.       
  58.      
  59.    protected 继承 
  60.     
  61.      
  62.       
  63.       
  64.         p 
  65.        
  66.       
  67.         r 
  68.        
  69.       
  70.         e 
  71.        
  72.       
  73.         v 
  74.        
  75.       
  76.         a 
  77.        
  78.       
  79.         t 
  80.        
  81.       
  82.         e 
  83.        
  84.       
  85.      
  86.        prevate 
  87.       
  88.      
  89.    prevate 继承**基类的  
  90.      
  91.       
  92.        
  93.        
  94.          p 
  95.         
  96.        
  97.          u 
  98.         
  99.        
  100.          b 
  101.         
  102.        
  103.          l 
  104.         
  105.        
  106.          i 
  107.         
  108.        
  109.          c 
  110.         
  111.        
  112.       
  113.         public 
  114.        
  115.       
  116.     public 成员**派生类的public成员派生类的  
  117.     
  118.      
  119.       
  120.       
  121.         p 
  122.        
  123.       
  124.         r 
  125.        
  126.       
  127.         o 
  128.        
  129.       
  130.         t 
  131.        
  132.       
  133.         e 
  134.        
  135.       
  136.         c 
  137.        
  138.       
  139.         t 
  140.        
  141.       
  142.         e 
  143.        
  144.       
  145.         d 
  146.        
  147.       
  148.      
  149.        protected 
  150.       
  151.      
  152.    protected 成员派生类的  
  153.     
  154.      
  155.       
  156.       
  157.         p 
  158.        
  159.       
  160.         r 
  161.        
  162.       
  163.         i 
  164.        
  165.       
  166.         v 
  167.        
  168.       
  169.         a 
  170.        
  171.       
  172.         t 
  173.        
  174.       
  175.         e 
  176.        
  177.       
  178.      
  179.        private 
  180.       
  181.      
  182.    private 成员**基类的  
  183.      
  184.       
  185.        
  186.        
  187.          p 
  188.         
  189.        
  190.          r 
  191.         
  192.        
  193.          o 
  194.         
  195.        
  196.          t 
  197.         
  198.        
  199.          e 
  200.         
  201.        
  202.          c 
  203.         
  204.        
  205.          t 
  206.         
  207.        
  208.          e 
  209.         
  210.        
  211.          d 
  212.         
  213.        
  214.       
  215.         protected 
  216.        
  217.       
  218.     protected 成员**派生类的  
  219.     
  220.      
  221.       
  222.       
  223.         p 
  224.        
  225.       
  226.         r 
  227.        
  228.       
  229.         o 
  230.        
  231.       
  232.         t 
  233.        
  234.       
  235.         e 
  236.        
  237.       
  238.         c 
  239.        
  240.       
  241.         t 
  242.        
  243.       
  244.         e 
  245.        
  246.       
  247.         d 
  248.        
  249.       
  250.      
  251.        protected 
  252.       
  253.      
  254.    protected 成员派生类的  
  255.     
  256.      
  257.       
  258.       
  259.         p 
  260.        
  261.       
  262.         r 
  263.        
  264.       
  265.         o 
  266.        
  267.       
  268.         t 
  269.        
  270.       
  271.         e 
  272.        
  273.       
  274.         c 
  275.        
  276.       
  277.         t 
  278.        
  279.       
  280.         e 
  281.        
  282.       
  283.         d 
  284.        
  285.       
  286.      
  287.        protected 
  288.       
  289.      
  290.    protected 成员派生类的  
  291.     
  292.      
  293.       
  294.       
  295.         p 
  296.        
  297.       
  298.         r 
  299.        
  300.       
  301.         i 
  302.        
  303.       
  304.         v 
  305.        
  306.       
  307.         a 
  308.        
  309.       
  310.         t 
  311.        
  312.       
  313.         e 
  314.        
  315.       
  316.      
  317.        private 
  318.       
  319.      
  320.    private 成员**基类的  
  321.      
  322.       
  323.        
  324.        
  325.          p 
  326.         
  327.        
  328.          r 
  329.         
  330.        
  331.          i 
  332.         
  333.        
  334.          v 
  335.         
  336.        
  337.          a 
  338.         
  339.        
  340.          t 
  341.         
  342.        
  343.          e 
  344.         
  345.        
  346.       
  347.         private 
  348.        
  349.       
  350.     private 成员**在派生类中不可见在派生类中不可见在派生类中不可见
  • 父类的 private成员在子类中无论以什么方式继承都是不可见的。这里的不可见是指父类的私有成员还是被继承到了子类对象中，但是语法上限制子类对象不管在类里面还是类外我们都不能去访问它- 子类想访问父类的 p r i v a t e private private 成员虽然不能直接访问，但能间接访问。虽然在子类中是不能访问，但在父类中并没有相关限制，只用父类提供相关访问 p r i v a t e private private 成员变量的成员函数，子类调用其函数就能间接访问。
  • 父类 p r i v a t e private private 成员在子类中是不能被访问的，如果父类成员不想在类外直接被访问，但需要在子类中能访问，就定义为 protected。可以看出保护成员限定符是因继承才出现的。
  • 实际上面的表格我们进行一下总结会发现，父类的私有成员在子类都是不可见。父类其他成员在子类的访问方式为： M i n Min Min（成员在父类的访问限定符， 继承方式）， p u b l i c public public >  p r o t e c t e d protected protected >  p r i v a t e private private。
  • 使用关键字 class 时默认的继承方式是private，使用 struct 时默认的继承方式是 public，不过最好显式的写出继承方式- class Student:Person //默认为private继承、struct Student:Person //默认为public继承
  • 在实际运用中一般使用的都是 p u b l i c public public 继承，几乎很少使用 p r o t e c t e d protected protected / p r i v a t e private private 继承，也不提倡使用 p r o t e c t e d protected protected / p r i v a t e private private 继承，因为 p r o t e c t e d protected protected / p r i v a t e private private 继承下来的成员都只能在子类的类里面使用，实际中扩展维护性不强。这里可以认为是 C++ 过度设计了。

  看起来上面的规则很复杂，实际实践过程中是很简单的，一般都是：父类我们就用公有和保护，继承方式我们就用公有。其他方式都很少使用。

1.3 继承类模板

  上述都是一些普通类的继承，那如果我们想继承类模板又该怎样呢？

  之前，我们模拟实现栈使用的适配器模式，其实还有一种方法：继承

  1. namespace ganyu
  2. {template<classT>classstack:public std::vector<T>{public:voidpush(const T& x){push_back(x);}voidpop(){vector<T>::pop_back();}const T&top(){returnvector<T>::back();}boolempty(){returnvector<T>::empty();}};}

  当基类是类模板时，需要

  1. 指定类域去访问

，否则会编译报错。（普通类的继承不存在这个问题）

  1. intmain(){
  2.     ganyu::stack<int> st;
  3.     st.push(1);
  4.     st.push(2);
  5.     st.push(3);while(!st.empty()){
  6.         cout << st.top()<<" ";
  7.         st.pop();}return0;}

在这里插入图片描述

  为什么编译报错呢？这与按需实例化有关系

  1. ganyu::stack<int> st;

这句代码实例化栈，将 

  1.      T 
  2.     
  3.    
  4.   
  5.     T 
  6.    
  7.   
  8. T 实例化成  
  9.  
  10.   
  11.    
  12.    
  13.      i 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     int 
  24.    
  25.   
  26. int，也间接将  
  27.  
  28.   
  29.    
  30.    
  31.      v 
  32.     
  33.    
  34.      e 
  35.     
  36.    
  37.      c 
  38.     
  39.    
  40.      t 
  41.     
  42.    
  43.      o 
  44.     
  45.    
  46.      r 
  47.     
  48.    
  49.   
  50.     vector 
  51.    
  52.   
  53. vector 实例化（严格来说只实例化了栈的构造函数）。但我们将  
  54.  
  55.   
  56.    
  57.    
  58.      v 
  59.     
  60.    
  61.      e 
  62.     
  63.    
  64.      c 
  65.     
  66.    
  67.      t 
  68.     
  69.    
  70.      o 
  71.     
  72.    
  73.      r 
  74.     
  75.    
  76.   
  77.     vector 
  78.    
  79.   
  80. vector 实例化时不会把  
  81.  
  82.   
  83.    
  84.    
  85.      v 
  86.     
  87.    
  88.      e 
  89.     
  90.    
  91.      c 
  92.     
  93.    
  94.      t 
  95.     
  96.    
  97.      o 
  98.     
  99.    
  100.      r 
  101.     
  102.    
  103.   
  104.     vector 
  105.    
  106.   
  107. vector 中所有的成员函数都实例化，我们调用谁才实例化谁。

  我们调用 

  1.      p 
  2.     
  3.    
  4.      u 
  5.     
  6.    
  7.      s 
  8.     
  9.    
  10.      h 
  11.     
  12.    
  13.   
  14.     push 
  15.    
  16.   
  17. push 函数时，编译器去找  
  18.  
  19.   
  20.    
  21.    
  22.      p 
  23.     
  24.    
  25.      u 
  26.     
  27.    
  28.      s 
  29.     
  30.    
  31.      h 
  32.     
  33.    
  34.   
  35.     push 
  36.    
  37.   
  38. push_ 
  39.  
  40.   
  41.    
  42.    
  43.      b 
  44.     
  45.    
  46.      a 
  47.     
  48.    
  49.      c 
  50.     
  51.    
  52.      k 
  53.     
  54.    
  55.   
  56.     back 
  57.    
  58.   
  59. back 函数，在子类和父类中都找不到，因为还没有实例化。所以我们要
  1. 指定类域去访问

，表示调用的是 

  1.      v 
  2.     
  3.    
  4.      e 
  5.     
  6.    
  7.      c 
  8.     
  9.    
  10.      t 
  11.     
  12.    
  13.      o 
  14.     
  15.    
  16.      r 
  17.     
  18.    
  19.   
  20.     vector 
  21.    
  22.   
  23. vector< 
  24.  
  25.   
  26.    
  27.    
  28.      T 
  29.     
  30.    
  31.   
  32.     T 
  33.    
  34.   
  35. T> 中的  
  36.  
  37.   
  38.    
  39.    
  40.      p 
  41.     
  42.    
  43.      u 
  44.     
  45.    
  46.      s 
  47.     
  48.    
  49.      h 
  50.     
  51.    
  52.   
  53.     push 
  54.    
  55.   
  56. push_ 
  57.  
  58.   
  59.    
  60.    
  61.      b 
  62.     
  63.    
  64.      a 
  65.     
  66.    
  67.      c 
  68.     
  69.    
  70.      k 
  71.     
  72.    
  73.   
  74.     back 
  75.    
  76.   
  77. back，此时编译器看到  
  78.  
  79.   
  80.    
  81.    
  82.      T 
  83.     
  84.    
  85.   
  86.     T 
  87.    
  88.   
  89. T 已经被实例化成  
  90.  
  91.   
  92.    
  93.    
  94.      i 
  95.     
  96.    
  97.      n 
  98.     
  99.    
  100.      t 
  101.     
  102.    
  103.   
  104.     int 
  105.    
  106.   
  107. int 了，就会将  
  108.  
  109.   
  110.    
  111.    
  112.      v 
  113.     
  114.    
  115.      e 
  116.     
  117.    
  118.      c 
  119.     
  120.    
  121.      t 
  122.     
  123.    
  124.      o 
  125.     
  126.    
  127.      r 
  128.     
  129.    
  130.   
  131.     vector 
  132.    
  133.   
  134. vector< 
  135.  
  136.   
  137.    
  138.    
  139.      T 
  140.     
  141.    
  142.   
  143.     T 
  144.    
  145.   
  146. T> 中的  
  147.  
  148.   
  149.    
  150.    
  151.      p 
  152.     
  153.    
  154.      u 
  155.     
  156.    
  157.      s 
  158.     
  159.    
  160.      h 
  161.     
  162.    
  163.   
  164.     push 
  165.    
  166.   
  167. push_ 
  168.  
  169.   
  170.    
  171.    
  172.      b 
  173.     
  174.    
  175.      a 
  176.     
  177.    
  178.      c 
  179.     
  180.    
  181.      k 
  182.     
  183.    
  184.   
  185.     back 
  186.    
  187.   
  188. back 实例化出一份  
  189.  
  190.   
  191.    
  192.    
  193.      i 
  194.     
  195.    
  196.      n 
  197.     
  198.    
  199.      t 
  200.     
  201.    
  202.   
  203.     int 
  204.    
  205.   
  206. int 版本的出来。

  我们可以结合 

  1. #define

，能灵活更改 

  1.      s 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      a 
  8.     
  9.    
  10.      c 
  11.     
  12.    
  13.      k 
  14.     
  15.    
  16.   
  17.     stack 
  18.    
  19.   
  20. stack 的底层容器，达到类似适配器模式的效果
  1. #defineCONTAINERvectornamespace ganyu
  2. {template<classT>classstack:public std::CONTAINER<T>{public:voidpush(const T& x){CONTAINER<T>::push_back(x);}voidpop(){CONTAINER<T>::pop_back();}const T&top(){returnCONTAINER<T>::back();}boolempty(){returnCONTAINER<T>::empty();}};}

2 父类和子类对象赋值兼容转换

    1.                                          p                               u                               b                               l                               i                               c                                      public                        public继承的前提下，**子类对象可以赋值给父类的对象 / 父类的指针 / 父类的引用**。这里有个形象的说法叫**切片**或者**切割**。寓意把子类中父类那部分切割开来赋值给父类对象/指针/引用
  • 但反过来就不成立：父类对象不能赋值给子类对象

在这里插入图片描述

  例如：现在有一个 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student 对象， 
  27.  
  28.   
  29.    
  30.    
  31.      S 
  32.     
  33.    
  34.      t 
  35.     
  36.    
  37.      u 
  38.     
  39.    
  40.      d 
  41.     
  42.    
  43.      e 
  44.     
  45.    
  46.      n 
  47.     
  48.    
  49.      t 
  50.     
  51.    
  52.   
  53.     Student 
  54.    
  55.   
  56. Student 对象可以赋值给父类对象  
  57.  
  58.   
  59.    
  60.    
  61.      P 
  62.     
  63.    
  64.      e 
  65.     
  66.    
  67.      r 
  68.     
  69.    
  70.      s 
  71.     
  72.    
  73.      o 
  74.     
  75.    
  76.      n 
  77.     
  78.    
  79.   
  80.     Person 
  81.    
  82.   
  83. Person，当然，指针和引用也是可以的；但反过来就不成立（总不能无中生有出一个 _ 
  84.  
  85.   
  86.    
  87.    
  88.      N 
  89.     
  90.    
  91.      o 
  92.     
  93.    
  94.   
  95.     No 
  96.    
  97.   
  98. No 成员吧）。
  1. classPerson{protected:
  2.     string _name;// 姓名
  3.     string _sex;// 性别int _age;// 年龄};classStudent:publicPerson{public:int _No;// 学号};intmain(){
  4.     Student sobj;// 1.派⽣类对象可以赋值给基类的对象/指针/引⽤
  5.     Person pobj = sobj;
  6.     Person* pp =&sobj;
  7.     Person& rp = sobj;//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错//sobj = pobj;return0;}

  这里并没有发生类型转换。
  虽然我们前面讲过不同类型的对象之间进行赋值，支持的是类型转换

  1. int i =0;double d = i;

  将 

  1.      i 
  2.     
  3.    
  4.   
  5.     i 
  6.    
  7.   
  8. i 赋值给  
  9.  
  10.   
  11.    
  12.    
  13.      d 
  14.     
  15.    
  16.   
  17.     d 
  18.    
  19.   
  20. d 走的就是类型转换，中间会生成一个**临时对象**。
  1. 但是切片并不是类型转换，中间并没有产生临时变量，这是一种特殊处理。
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的 dynamic_cast 来进行识别后进行安全转换。（ps：这个我们后面再单独专门介绍，这里先提⼀下）

3 继承中的作用域

3.1 隐藏规则

  • 在继承体系中父类和子类都有独立的作用域
  • 子类和父类中有同名成员，子类成员将屏蔽父类的同名成员的直接访问，这种情况叫 隐藏。（在子类成员函数中，可以使用父类::父类成员 显式访问）
  1. classPerson{protected:
  2.     string _name ="小帅";// 姓名int _num =111;// ⾝份证号};classStudent:publicPerson{public:voidPrint(){
  3.         cout <<" 姓名:"<< _name << endl;
  4.         cout <<" 身份证号:"<< Person::_num << endl;//指定父类的类域进行访问
  5.         cout <<" 学号:"<< _num << endl;}protected:int _num =999;// 学号};intmain(){
  6.     Student s1;
  7.     s1.Print();return0;}

运行结果：

在这里插入图片描述

  • 如果是成员函数的隐藏，只需要函数名相同就构成隐藏
  • 注意：在实际中在继承体系里面最好不要定义重名的成员或函数

3.2 例题

  1. classA{public:voidfun(){
  2.         cout <<"func()"<< endl;}};classB:publicA{public:voidfun(int i){
  3.         cout <<"func(int i)"<< i << endl;}};intmain(){
  4.     B b;
  5.     b.fun(10);
  6.     b.fun();return0;};
    1.                                          A                                      A                        A 和                                              B                                      B                        B 类中的两个                                              f                               u                               n                               c                                      func                        func函数 构成什么关系（） A. 重载   B. 隐藏  C.没关系
  2. 下面程序的编译运行结果是什么（） A. 编译报错  B. 运行报错  C. 正常运行
  • 第一题：第一眼看上去，他们构成重载关系：函数名相同，参数类型不同。但如果选 A 就错了，这题选B。别忘了，只有在同一作用域的函数才构成函数重载，而隐藏是父类和子类中的函数名相同就构成隐藏
  • 第二题：选A，因为子类和父类的 f u n c func func函数 构成隐藏，除非指定父类的作用域去调用，否则同名成员或函数是不会去父类中查找的。b.fun(); 没有传递参数，编译报错。

4 子类的默认成员函数

  6 个默认成员函数，意思是我们不写，编译器会给我们自动生成。父类的默认成员函数与普通类没有任何差别，但在派生类中，这几个成员函数是如何生成的呢？

4.1 构造函数

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

4.1.1 父类有默认构造

  1. classPerson{public:Person(constchar* name ="peter"):_name(name){
  2.         cout <<"Person()"<< endl;}protected:
  3.     string _name;// 姓名};classStudent:publicPerson{public:protected:int _num;//学号
  4.     string _sex;//性别};

首先，我们来回忆一下普通类的默认生成的构造函数的行为：

  • 对内置类型：默认生成的构造函数是不确定的
  • 对自定义类型：会调用它的默认构造函数

现在，比起之前多出来一部分：

  1. 父类成员
  • 我们把继承的父类成员看成一个整体对象，子类的默认构造会自动调用父类的默认构造完成父类成员的初始化

在这里插入图片描述

4.1.2 父类没有默认构造

  1. classPerson{public:Person(constchar* name,double height):_name(name),_height(height){
  2.         cout <<"Person()"<< endl;}protected:
  3.     string _name;// 姓名double _height;//身高};classStudent:publicPerson{public:protected:int _num;//学号
  4.     string _sex;//性别};

  现在，父类没有默认构造，派生类还能默认生成构造函数吗？.

在这里插入图片描述

  可见，默认生成的只能调用默认构造。这时，就需要我们在子类显式写一个构造函数了

  1. Student(constchar* name,double height,int num,constchar* sex):_name(name),_height(height),_num(num),_sex(sex){}

  这样写可不可以呢？
  不可以。编译器不允许直接去初始化父类的成员，子类要求必须调用父类的构造函数来初始化父类的成员，要把父类当成一个整体。

显示调用父类方法如下：

  1. Student(constchar* name,double height,int num,constchar* sex):Person(name, height),_num(num),_sex(sex){}intmain(){
  2.     Student s1("张三",1.80,1,"男");
  3.     Student s2("李四",1.70,2,"未知");return0;}

  有点像调用一个匿名对象一样。

4.2 拷贝构造

派生类的拷贝构造函数必须调用基类的拷贝构造完成基本的拷贝初始化

对默认生成的拷贝构造，其行为也像上述构造函数一样分成三类

  • 内置类型：完成浅拷贝
  • 自定义类型：调用其拷贝构造
  • 父类整体：调用父类的拷贝构造

4.2.1 不需要自己显式写

  1. classPerson{public:Person(constchar* name ="peter"):_name(name){
  2.         cout <<"Person()"<< endl;}Person(const Person& p):_name(p._name){
  3.         cout <<"Person(const Person& p)"<< endl;}protected:
  4.     string _name;// 姓名};classStudent:publicPerson{public://构造函数Student(constchar* name,int num,constchar* sex):Person(name),_num(num),_sex(sex){}//未写拷贝构造//···protected:int _num;//学号
  5.     string _sex;//性别};intmain(){
  6.     Student s1("张三",1,"男");
  7.     Student s2 = s1;return0;}

在这里插入图片描述

  严格来说， 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student类是不用我们自己写拷贝构造的，默认生成的拷贝构造已经完成了我们的需求。前面，我们通过学习知道拷贝构造、赋值重载、析构是一体的。一个不需要写，三个都不需要写；一个要写，三个都要写。因此  
  27.  
  28.   
  29.    
  30.    
  31.      S 
  32.     
  33.    
  34.      t 
  35.     
  36.    
  37.      u 
  38.     
  39.    
  40.      d 
  41.     
  42.    
  43.      e 
  44.     
  45.    
  46.      n 
  47.     
  48.    
  49.      t 
  50.     
  51.    
  52.   
  53.     Student 
  54.    
  55.   
  56. Student类 的赋值重载和析构函数都不需要自己写

  如果有需要深拷贝的资源，才需要自己实现

4.2.2 自己显式写

  那假设 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student 类中有指向的资源，需要我们自己写拷贝构造，又该怎么写呢？
  1. classStudent:publicPerson{public:protected:int _num;//学号
  2.     string _sex;//性别int* _ptr =newint[10];//假设有指向的资源};
  1. Student(const Student& s):_num(s._num),_sex(s._sex),//显示调用父类的拷贝构造{//深拷贝memcpy(_ptr, s._ptr,sizeof(int)*10);}

  如何显式调用父类的拷贝构造呢？

调用父类的拷贝构造，需要传递父类的对象，但现在没有父类的对象，咋办呢？
  这时，我们就可以运用前面学习的赋值兼容转换

  1. Student(const Student& s):_num(s._num),_sex(s._sex),Person(s){//深拷贝memcpy(_ptr, s._ptr,sizeof(int)*10);}
  1. Person(s)

： 

  1.      s 
  2.     
  3.    
  4.   
  5.     s 
  6.    
  7.   
  8. s 是子类对象的引用，要拷贝父类那一部分，需要将父类那一部分拿出来， 怎么拿出来呢？我把子类对象传给父类的引用，这时父类的引用，**引用的是子类对象中切割出来的父类的那一部分**。

  这里有个小细节，走初始化列表时，编译器会先走

  1. Person(s)

，在走

  1. _num(s._num)

和

  1. _sex(s._sex)

  这是因为初始化列表初始化的顺序与成员在列表中的顺序无关，只与声明的顺序有关。
  所以继承以后，它将父类对象当成一个整体，而父类对象是最先被声明的

  那如果不在初始化列表显示初始化父类呢？

  1. Student(const Student& s):_num(s._num),_sex(s._sex){//深拷贝}

  我们说过，所有成员都会走初始化列表，父类 

  1.      P 
  2.     
  3.    
  4.      e 
  5.     
  6.    
  7.      r 
  8.     
  9.    
  10.      s 
  11.     
  12.    
  13.      o 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.   
  20.     Person 
  21.    
  22.   
  23. Person 没有显示调用，也会走初始化列表。但此时**编译器会调用  
  24.   
  25.    
  26.     
  27.     
  28.       P 
  29.      
  30.     
  31.       e 
  32.      
  33.     
  34.       r 
  35.      
  36.     
  37.       s 
  38.      
  39.     
  40.       o 
  41.      
  42.     
  43.       n 
  44.      
  45.     
  46.    
  47.      Person 
  48.     
  49.    
  50.  Person 的默认构造**，虽然编译能通过，但**很可能不符合你的需求**；如果  
  51.  
  52.   
  53.    
  54.    
  55.      P 
  56.     
  57.    
  58.      e 
  59.     
  60.    
  61.      r 
  62.     
  63.    
  64.      s 
  65.     
  66.    
  67.      o 
  68.     
  69.    
  70.      n 
  71.     
  72.    
  73.   
  74.     Person 
  75.    
  76.   
  77. Person 没有默认构造，那么**编译报错**

4.3 赋值重载

  和拷贝构造一样， 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student 类严格来说不需要写赋值。

  但如果我们需要显式写要怎么写呢

  • 派生类的 o p e r a t o r operator operator= 必须要调用基类的 o p e r a t o r operator operator =。
  1. Student&operator=(const Student& s){if(this!=&s){operator=(s);
  2.         _num = s._num;
  3.         _sex = s._sex;}return*this;}

  复制拷贝与拷贝构造是类似的，都是传递子类对象的引用给父类即可。

  但是，如果运行程序会发现：

  1. 程序陷入死循环

。
  为什么呢？
子类中的同名函数与父类的构成了隐藏！

  1. operator=(s);

其实一直调的是子类的 

  1.      o 
  2.     
  3.    
  4.      p 
  5.     
  6.    
  7.      e 
  8.     
  9.    
  10.      r 
  11.     
  12.    
  13.      a 
  14.     
  15.    
  16.      t 
  17.     
  18.    
  19.      o 
  20.     
  21.    
  22.      r 
  23.     
  24.    
  25.   
  26.     operator 
  27.    
  28.   
  29. operator=，因此程序陷入死循环

  因此我们要指定调用定父类的 

  1.       o 
  2.      
  3.     
  4.       p 
  5.      
  6.     
  7.       e 
  8.      
  9.     
  10.       r 
  11.      
  12.     
  13.       a 
  14.      
  15.     
  16.       t 
  17.      
  18.     
  19.       o 
  20.      
  21.     
  22.       r 
  23.      
  24.     
  25.    
  26.      operator 
  27.     
  28.    
  29.  operator=。
  1. Student&operator=(const Student& s){if(this!=&s){
  2.         Person::operator=(s);
  3.         _num = s._num;
  4.         _sex = s._sex;}return*this;}

总结：派生类的 

  1.      o 
  2.     
  3.    
  4.      p 
  5.     
  6.    
  7.      e 
  8.     
  9.    
  10.      r 
  11.     
  12.    
  13.      a 
  14.     
  15.    
  16.      t 
  17.     
  18.    
  19.      o 
  20.     
  21.    
  22.      r 
  23.     
  24.    
  25.   
  26.     operator 
  27.    
  28.   
  29. operator= 必须要调用基类的  
  30.  
  31.   
  32.    
  33.    
  34.      o 
  35.     
  36.    
  37.      p 
  38.     
  39.    
  40.      e 
  41.     
  42.    
  43.      r 
  44.     
  45.    
  46.      a 
  47.     
  48.    
  49.      t 
  50.     
  51.    
  52.      o 
  53.     
  54.    
  55.      r 
  56.     
  57.    
  58.   
  59.     operator 
  60.    
  61.   
  62. operator= 完成基类的赋值。需要注意的是派生类的  
  63.  
  64.   
  65.    
  66.    
  67.      o 
  68.     
  69.    
  70.      p 
  71.     
  72.    
  73.      e 
  74.     
  75.    
  76.      r 
  77.     
  78.    
  79.      a 
  80.     
  81.    
  82.      t 
  83.     
  84.    
  85.      o 
  86.     
  87.    
  88.      r 
  89.     
  90.    
  91.   
  92.     operator 
  93.    
  94.   
  95. operator= 屏蔽了基类的  
  96.  
  97.   
  98.    
  99.    
  100.      o 
  101.     
  102.    
  103.      p 
  104.     
  105.    
  106.      e 
  107.     
  108.    
  109.      r 
  110.     
  111.    
  112.      a 
  113.     
  114.    
  115.      t 
  116.     
  117.    
  118.      o 
  119.     
  120.    
  121.      r 
  122.     
  123.    
  124.   
  125.     operator 
  126.    
  127.   
  128. operator=，所以**显式调用基类的 operator=，需要指定基类作用域**

4.4 析构函数

  首先，严格来说 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student 并不需要我们显式写析构函数

  那如果有需要显式释放的资源，析构函数又该怎么写呢？

4.4.1 重载

  我们还是以 

  1.      S 
  2.     
  3.    
  4.      t 
  5.     
  6.    
  7.      u 
  8.     
  9.    
  10.      d 
  11.     
  12.    
  13.      e 
  14.     
  15.    
  16.      n 
  17.     
  18.    
  19.      t 
  20.     
  21.    
  22.   
  23.     Student 
  24.    
  25.   
  26. Student类 为例

  首先，如果显式实现析构函数，_ 

  1.      n 
  2.     
  3.    
  4.      u 
  5.     
  6.    
  7.      m 
  8.     
  9.    
  10.   
  11.     num 
  12.    
  13.   
  14. num 和 _ 
  15.  
  16.   
  17.    
  18.    
  19.      s 
  20.     
  21.    
  22.      e 
  23.     
  24.    
  25.      x 
  26.     
  27.    
  28.   
  29.     sex 
  30.    
  31.   
  32. sex 是不用管的。因为
  1. int _num

是内置类型，而 

  1. string _sex

会自己调用其析构。我们只需要管父类即可

  1. ~Student(){~Person();}

  但这样会报错

在这里插入图片描述

  析构是可以显示调用的，但为什么这里调不动呢？

  这里有个小知识点：子类的析构会和父类的析构构成隐藏关系。
  因为一些特殊的原因，析构函数的函数名会被特殊处理成 

  1.        d 
  2.       
  3.      
  4.        e 
  5.       
  6.      
  7.        s 
  8.       
  9.      
  10.        t 
  11.       
  12.      
  13.        r 
  14.       
  15.      
  16.        u 
  17.       
  18.      
  19.        c 
  20.       
  21.      
  22.        t 
  23.       
  24.      
  25.        o 
  26.       
  27.      
  28.        r 
  29.       
  30.      
  31.     
  32.       destructor 
  33.      
  34.     
  35.   destructor()，所以父类的析构函数和子类的析构函数构成隐藏关系。实际上并没有什么 ~ 
  36.  
  37.   
  38.    
  39.    
  40.      S 
  41.     
  42.    
  43.      t 
  44.     
  45.    
  46.      u 
  47.     
  48.    
  49.      d 
  50.     
  51.    
  52.      e 
  53.     
  54.    
  55.      n 
  56.     
  57.    
  58.      t 
  59.     
  60.    
  61.   
  62.     Student 
  63.    
  64.   
  65. Student() 和 ~ 
  66.  
  67.   
  68.    
  69.    
  70.      P 
  71.     
  72.    
  73.      e 
  74.     
  75.    
  76.      r 
  77.     
  78.    
  79.      s 
  80.     
  81.    
  82.      o 
  83.     
  84.    
  85.      n 
  86.     
  87.    
  88.   
  89.     Person 
  90.    
  91.   
  92. Person()，只有  
  93.  
  94.   
  95.    
  96.    
  97.      d 
  98.     
  99.    
  100.      e 
  101.     
  102.    
  103.      s 
  104.     
  105.    
  106.      t 
  107.     
  108.    
  109.      r 
  110.     
  111.    
  112.      u 
  113.     
  114.    
  115.      c 
  116.     
  117.    
  118.      t 
  119.     
  120.    
  121.      o 
  122.     
  123.    
  124.      r 
  125.     
  126.    
  127.   
  128.     destructor 
  129.    
  130.   
  131. destructor()。

  所以我们要

  1. 指定类域调用
  1. ~Student(){Person::~Person();}

4.4.2 顺序

  我们来尝试调用一下析构函数

  1. classPerson{public://成员函数//···~Person(){
  2.         cout <<"~Person()"<< endl;}protected:
  3.     string _name;// 姓名};classStudent:publicPerson{public://成员函数//···~Student(){Person::~Person();}protected:int _num;//学号
  4.     string _sex;//性别};intmain(){
  5.     Student s1("张三",1,"男");
  6.     Student s2("李四",2,"未知");return0;}

运行结果：

在这里插入图片描述

  大家有没有发现析构函数调的有点多啊，我一个就两个对象，你怎么就调用 4 次析构函数了呢？

  像构造、赋值重载等，我们显式写的都需要显式调用父类的对应函数，但析构不需要显式调用。调用了子类析构函数之后，系统会自动调用父类的析构（这点与自定义类型的成员很像）。

  为什么要这样的。这样可以保证析构顺序是先子后父。后定义的先析构，而对象构造时，是先构造（初始化）父类，在初始化子类；析构是就需要先析构子类，在析构父类。如果显式调用就不能保证先子后父，而是取决于实现的人。

4.5 实现不能被继承的类

  要实现一个不能被继承的类，有两种方法

4.5.1 法一：设为私有

将父类的构造函数设置为私有

  1. classBase{public:voidfunc5(){ cout <<"Base::func5"<< endl;}protected:int a =1;private:// C++98的⽅法Base(){}};classDerive:publicBase{voidfunc4(){ cout <<"Derive::func4"<< endl;}protected:int b =2;};

  为什么呢？因为子类的构造函数，不论是自动生成还是我们自己显式实现，都必须调用父类的构造函数。但是父类的 

  1.      p 
  2.     
  3.    
  4.      r 
  5.     
  6.    
  7.      i 
  8.     
  9.    
  10.      v 
  11.     
  12.    
  13.      a 
  14.     
  15.    
  16.      t 
  17.     
  18.    
  19.      e 
  20.     
  21.    
  22.   
  23.     private 
  24.    
  25.   
  26. private成员在子类中是不可见的，因此**子类调不到父类的构造函数**。

  但是这种方式不够明显，如果不调用子类的对象编译器是不会报错的

4.5.2 法二：final

  C++11中新增了一个关键字： 

  1.       f 
  2.      
  3.     
  4.       i 
  5.      
  6.     
  7.       n 
  8.      
  9.     
  10.       a 
  11.      
  12.     
  13.       l 
  14.      
  15.     
  16.    
  17.      final 
  18.     
  19.    
  20.  final

  用 

  1.      f 
  2.     
  3.    
  4.      i 
  5.     
  6.    
  7.      n 
  8.     
  9.    
  10.      a 
  11.     
  12.    
  13.      l 
  14.     
  15.    
  16.   
  17.     final 
  18.    
  19.   
  20. final 修饰一个类，表示**该类是最终类，无法再被继承**。

  这种方式更直观一些，不管子类定不定义，直接报错

  1. classBase final
  2. {public:Base(){}voidfunc5(){ cout <<"Base::func5"<< endl;}protected:int a =1;};classDerive:publicBase{voidfunc4(){ cout <<"Derive::func4"<< endl;}protected:int b =2;};

在这里插入图片描述

4.6 总结

  • 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表显示调用
  • 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
  • 派生类的 o p e r a t o r operator operator= 必须要调用基类的 o p e r a t o r operator operator= 完成基类的复制。需要注意的是派生类的 o p e r a t o r operator operator= 隐藏了基类的 o p e r a t o r operator operator=，所以显示调用基类的 operator=，需要指定基类作用域
  • 派生类的析构函数会在被调用完成之后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员在清理基类成员的顺序
  • 派生类对象初始化先调用基类的构造再调派生类的构造
  • 派生类对象析构清理先调用派生类析构再调基类的析构
  • 因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数进行特殊处理 ，处理成 d e s t r u c t o r destructor destructor()，所以基类析构函数不加 virtual 的情况下，派生类析构函数和基类析构函数构成隐藏关系
  • 大多数情况下，派生类中拷贝构造、赋值、析构都是不需要自己写的；如果需要，那这个继承的设计太过复杂，可以考虑重新设计。

好啦，本期关于继承的知识就介绍到这里啦，希望本期博客能对你有所帮助。同时，如果有错误的地方请多多指正，让我们在 C++ 的学习路上一起进步！

标签： c++ jvm 开发语言
本文转载自: https://blog.csdn.net/yusjushd/article/details/142147767
版权归原作者 9毫米的幻想 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【C++】—— 继承（上）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？