C++ day25 代码重用（一） 包含，私有继承，保护继承

小咪咪 2023-07-24 02:17 30阅读 0赞

C++的各种先进理念中包含了一条:代码重用。上一章学习的公有继承是实现代码重用理念的方式之一，但是还有多种机制可以实现这个理念：

  • 私有继承
  • 保护继承
  • 包含/组合/层次化（containment/composition/layering）：把一个类的对象作为另一个类的成员
  • 多重继承multiple inheritance，MI：可以是多重私有继承，也可以是多重公有继承（容易出问题）

  • 类模板
    前面三个都用于实现has

    文章目录

    • 包含
      • 示例 学生类
        • 在编译阶段出现错误优于在运行阶段出现错误
        • 公有继承中，类可以继承接口；包含不可以继承接口
        • 代码
    • 私有继承：基类的公有成员和保护成员都成为派生类的私有成员
      • 私有继承 VS 包含
      • 示例 重新设计Student类
        • 私有继承怎么访问基类方法和对象
        • 代码
    • 保护继承（私有继承的变体）
      • 保护继承 VS 私有继承
      • 公有继承 VS 保护继承 VS 私有继承
    • 重新定义保护派生和私有派生的访问权限（即希望让派生类对象可以在类外部调用基类方法）
      • 把函数调用包装在另一个函数调用中
      • 像名称空间一样，使用using声明指出派生类可以使用基类的特定成员

包含

示例 学生类

在这里插入图片描述
我们用最后一个定义来表示学生，因为这样才适合计算机表示。即把学生简化和抽象为一个姓名和一组分数。

姓名怎么表示？可以用C语言的字符数组，或者用字符指针char*和动态内存分配，或者直接用string类。当然最简单的选择是string类啦，因为字符数组的长度很难确定，char指针需要多写一些代码，而string类是C++库提供的，库里有所有的实现代码，而且都是很好的实现，经过了严格测试。

分数也可以用一个定长的double数组，或者使用new的动态数组，或者C++提供的valarray类。同样的原因，当然是选择valarray类。

valarray类：用于处理数值的模板类
这是个模板类，即类型不确定，由实现决定，也就可以处理各种不同的数据类型。他支持一些算术运算：把数组所有元素相加以及在数组中找到最大值和最小值等操作。

  1. #include <valarray>
  2. #include <iostream>
  4. int mian()
  5. { 
  6.     using std::cout;
  7.     using std::valarray;
  9.     valarray<int> q_values; //int array,长度为0的空数组
  10.     valarray<double> weights; //double array
  11.     double gpa[5] = { 2.1, 5.2, 4.1, 6.3, 8.4};
  12.     valarray<double> v1;//size 0
  13.     valarray<int> v2(8); //指定长度的空数组，size 8，可放8个int元素，用的是圆括号哦
  14.     valarray<int> v3(10, 8); //size是8，所有元素被初始化为指定值10，第一个参数是初始值，第二个参数是size
  15.     valarray<double> v4(gpa, 4);//size是4，把gpa数组的前四个元素的值作为初始值，用常规数组的值去初始化
  16.     valarray<int> v5 = { 12, 45, 78, 96};//使用初始化列表
  17.     cout << v3[0](0);
  18.     return 0;
  19. }

由于学生拥有名字和分数，所以Student类和string类，valarray类都是has-a关系，而不是is-a关系，不能用公有继承，要用包含。

在编译阶段出现错误优于在运行阶段出现错误

所以C++要用explicit，const等关键字去做一些限制。

公有继承中，类可以继承接口；包含不可以继承接口

公有继承一般是处理is-a关系，派生类可以继承基类的接口（即基类的纯虚函数）和实现，获得接口是is-a关系的一部分，因为既然是一种，那么就要有一样的接口和实现。

但是包含关系中，has-a关系，类并不能获得自己包含的对象所属的类的接口，只能在方法代码中调用一下对象所属类的方法，实现代码重用，这在下面的代码中有体现。

对于has-a关系，类对象不能获得被包含对象的接口是合理的，还是件好事。比如Student类包含了string类的对象，但Student类并不需要获得string类的各种方法和接口啊，比如把两个string对象串接起来，就不适用于Student类嘛。

代码

  1. //Student.h
  2. #ifndef STUDENT_H_
  3. #define STUDENT_H_
  4. #include <iostream>
  5. #include <string>
  6. #include <valarray>
  7. class Student{ 
  8. private:
  9.     typedef std::valarray<double> arrayDb;//typedef放在类的私有部分则只有Student类的实现中可以使用arrayDb,Student类外不可以
  10.     std::string name;
  11.     arrayDb scores;//没指定size
  12.     std::ostream & arr_out(std::ostream & os) const;
  13. public:
  14.     Student()
  15.         :name("Null Null"),scores(){ }//分数可以留着括号
  16.     //由于单参数的构造函数可以用作从参数类型到类类型的隐式类型转换函数，但是把int转换为Student类毫无意义，所以要用explicit关闭隐式转换
  17.     explicit Student(const std::string & s)
  18.         :name(s), scores(){ }//只传入一个参数（名字），避免隐式自动类型准换
  19.     explicit Student(int n):name("Null"), scores(n){ }//只传入一个参数（分数数组的元素个数），避免隐式自动类型准换
  20.     Student(const std::string & s, int n)
  21.         :name(s), scores(n){ }
  22.     Student(const std::string & s, const arrayDb & a)
  23.         :name(s), scores(a){ }
  24.     Student(const char * str, const double * pd, int n)
  25.         :name(str),scores(pd, n){ }
  26.     ~Student(){ }
  27.     double Average() const;
  28.     const std::string & Name() const;
  29.     double & operator[](int i);
  30.     double operator[](int i) const;
  31.     //friends
  32.     //输入
  33.     friend std::istream & operator>>(std::istream & is, Student & stu);// 1 word
  34.     friend std::istream & getline(std::istream & is, Student & stu);//1 line
  35.     //输出
  36.     friend std::ostream & operator<<(std::ostream & os, const Student & stu);
  38. };
  39. #endif
  41. //Student.cpp
  42. #include <iostream>
  43. #include "Student.h"
  45. //私有方法(当做辅助函数来用)
  46. //输出分数,通过把输出分数的凌乱细节包装在一个私有函数里，可以使得友元函数代码更简洁整洁，也隐藏了实现
  47. std::ostream & Student::arr_out(std::ostream & os) const
  48. { 
  49.     int i;
  50.     int lim = scores.size();//虽然被包含对象的接口不是公有的，但是在类方法中可以使用他们
  51.     if (lim > 0)
  52.     { 
  53.         for (i = 0; i < lim; ++i)
  54.         { 
  55.             os << scores[i] << ' ';
  56.             if (i % 5 == 4)//一行5个数
  57.                 os << '\n';
  58.         }
  59.         if (i % 5 != 0)
  60.             os << std::endl;
  61.     }
  62.     else
  63.         os << "empty array!\n";
  65.     return os;
  66. }
  68. double Student::Average() const
  69. { 
  70.     if (scores.size() > 0)
  71.         return scores.sum()/scores.size();
  72.     else
  73.         return 0;
  74. }
  76. const std::string & Student::Name() const
  77. { 
  78.     return name;
  79. }
  81. double & Student::operator[](int i)
  82. { 
  83.     //按引用返回
  84.     return scores[i];//这里用的是valarray<double>::operator[]()函数
  85. }
  87. double Student::operator[](int i) const
  88. { 
  89.     return scores[i];//按值返回
  90. }
  92. //输入
  93. std::istream & operator>>(std::istream & is, Student & stu)// 1 word
  94. { 
  95.     is >> stu.name;
  96.     return is;
  97. }
  99. std::istream & getline(std::istream & is, Student & stu)//1 line
  100. { 
  101.     getline(is, stu.name);//调用string类的友元函数getline(istream &, const string &)
  102.     return is;
  103. }
  105. //输出
  106. std::ostream & operator<<(std::ostream & os, const Student & stu)
  107. { 
  108.     os << "Scores for " << stu.name << ": "; //友元函数可以访问name成员, stu.name是string类对象，所以会调用string类的operator<<(ostream &, const string &)
  109.     return stu.arr_out(os);
  110. }

主程序

  1. #include <valarray>
  2. #include <iostream>
  3. #include "Student.h"
  4. using std::cout;
  5. void set(Student & sa, int n);
  7. int main()
  8. { 
  9.     using std::valarray;
  10.     const int pupils = 3;
  11.     const int quizzes = 5;
  13.     Student ada[pupils] = { Student(quizzes), Student(quizzes), Student(quizzes)};
  14.     for (int i = 0; i < pupils; ++i)
  15.         set(ada[i], quizzes);
  17.     cout << "Student list:\n";
  18.     for (int i = 0; i < pupils; ++i)
  19.         cout << ada[i] << std::endl;
  21.     return 0;
  22. }
  24. void set(Student & sa, int n)
  25. { 
  26.     using std::cin;
  27.     cout << "Enter the student's name: ";
  28.     getline(cin, sa);//Student类的友元函数
  29.     cout << "Enter " << n << " quiz scores:\n";
  30.     for (int i = 0; i < n; ++i)
  31.         cin >> sa[i];//??把对象名当做数组名用？
  32.     //清空输入队列
  33.     while (cin.get() != '\n')
  34.         ;
  35. }

输出

  1. Enter the student's name: Gil Bayts Enter 5 quiz scores: 78 56 79 85 69 Enter the student's name: Pat Roone
  2. Enter 5 quiz scores:
  3. 98.5 45.6 86.2 96.3
  4. 52.3
  5. Enter the student's name: Fleur Oday
  6. Enter 5 quiz scores:
  7. 78.1 45.2 85 69 36.5 78.6 21
  8. Student list:
  9. Scores for Gil Bayts: 78 56 79 85 69
  11. Scores for Pat Roone: 98.5 45.6 86.2 96.3 52.3
  13. Scores for Fleur Oday: 78.1 45.2 85 69 36.5

私有继承：基类的公有成员和保护成员都成为派生类的私有成员

即基类的公有方法和保护方法都成了派生类的私有方法。

所以基类的方法并不会成为派生类对象的公有接口的一部分，但是可以在派生类的成员函数中使用他们。

因此私有继承也（包含不继承接口）不会继承基类的接口。

私有继承 VS 包含

  • 相同：都只获得实现，不获得接口
  • 不同：
  1. 对象是否命名，包含把一个命名了的子对象（成员对象）添加在类中；私有继承把对象作为一个没有命名的继承对象添加在类中，即只继承组件，而不是创建成员对象。

  2. 由于私有继承没有显式命名对象，所以代码会有不同，比如内联构造函数中的初始化成员列表使用的是类名，而包含使用的对象名。

    • 怎么选择:
      包含和私有继承都可以实现has-a关系，但是更倾向于使用包含实现has-a关系。因为：

包含优点 ：易于理解，可以用显式命名被包含类（这里不叫基类）的对象，代码好写。

私有继承缺点：可能会很麻烦：从多个基类进行多重私有继承时，也许多个基类有同名函数，或者基类之间共享了一个祖先基类。另外，私有继承最多只可以用到一个基类对象（因为对象没有名称难以区分），但是包含可以创建多个基类对象。

私有继承的优点：提供的特性比包含多。
比如，包含类和被包含类不是继承关系，所以包含类不在继承链条中，所以包含类不可以访问被包含类的保护成员（函数或数据），但是继承链条中的派生类就可以访问保护成员。

  • 必须使用私有继承而不是包含的情况：
  1. 需要访问原类的保护成员
  2. 新类需要重新定义虚函数，因为只有派生类可以重新定义虚函数，包含类不可以。

示例 重新设计Student类

改变并不大，只是以前包含中使用了对象名的地方需要改

私有继承怎么访问基类方法和对象

  • 访问基类的公有方法：用类名和作用域解析运算符（包含使用对象名调用基类的公有方法）
    在这里插入图片描述

    double Student::Average() const
    { 

    1. if (ArrayDb::size() > 0)
    2.     return ArrayDb::sum() / ArrayDb::size();//用类名和作用域解析运算符调用基类的方法
    3. else
    4.     return 0;

    }

  • 访问基类对象：强制类型转换
    Student类是string类派生的，所以可以强制类型转换为string类对象，即继承来的string类对象

    const std::string & Student::Name() const
    { 

    1. return (const std::string &) *this;//通过强制类型转换创建一个引用指向继承来的基类对象
    2. //（把Student对象强制转换为基类string类对象），以访问基类对象

    }

  • 访问基类的友元函数
    答案是：仍然是强制类型转换。由于友元函数并不属于类，所以肯定不能用类名和作用域解析运算符。

私有继承中，如果不显示类型转换，则不可以把派生类的指针或者引用赋给基类的指针或引用。

  1. std::istream & operator>>(std::istream & is, Student & stu)
  2. { 
  3.     is >> (std::string &)stu;//强制类型转换得到基类对象以调用基类的友元函数operator<<(ostream &, const string &)
  4.     return is;
  5. }

代码

  1. //student.h
  2. #ifndef STUDENT_H_
  3. #define STUDENT_H_
  4. #include <iostream>
  5. #include <valarray>
  6. #include <string>
  7. //私有继承
  8. class Student : private std::string, private std::valarray<double>
  9. { 
  10.     private:
  11.         typedef std::valarray<double> ArrayDb;
  12.         std::ostream & arr_out(std::ostream & os) const;
  13.     public:
  14.         //0个参数，即只声明
  15.         Student():std::string("Null Null"), ArrayDb(){ }//括号空着
  16.         //单个参数
  17.         explicit Student(const std::string & s):std::string(s), ArrayDb(){ }
  18.         explicit Student(int n):std::string("Null Null"), ArrayDb(n){ }
  19.         //两个参数，只传入分数数组的元素个数
  20.         Student(const std::string & s, int n):std::string(s), ArrayDb(n){ }
  21.         //两个参数，传入分数数组的引用
  22.         Student(const std::string & s, const ArrayDb & ar):std::string(s), ArrayDb(ar){ }
  23.         ~Student(){ }
  24.         double Average() const;
  25.         double & operator[](int i);
  26.         double operator[](int i) const;
  27.         const std::string & Name() const;
  28.         //friends
  29.         //输入
  30.         friend std::istream & operator>>(std::istream & is, Student & stu);//输入一个词语
  31.         friend std::istream & getline(std::istream & is, Student & stu);//输入一行
  32.         //输出
  33.         friend std::ostream & operator<<(std::ostream & os, const Student & stu);
  35. };
  36. #endif
  38. //student.cpp
  39. #include <iostream>
  40. #include <string>
  41. #include "studenti.h"
  42. //public
  43. double Student::Average() const
  44. { 
  45.     if (ArrayDb::size() > 0)
  46.         return ArrayDb::sum() / ArrayDb::size();//用类名和作用域解析运算符调用基类的方法
  47.     else
  48.         return 0;
  49. }
  51. const std::string & Student::Name() const
  52. { 
  53.     return (const std::string &) *this;//通过强制类型转换创建一个引用（把Student对象强制转换为基类string类对象），以访问基类对象
  54. }
  56. double & Student::operator[](int i)
  57. { 
  58.     return ArrayDb::operator[](i);//调用基类方法
  59. }
  61. double Student::operator[](int i) const
  62. { 
  63.     return ArrayDb::operator[](i);
  64. }
  66. //private
  67. std::ostream & Student::arr_out(std::ostream & os) const
  68. { 
  69.     int i;
  70.     int lim = ArrayDb::size();
  71.     if (lim > 0)
  72.     { 
  73.         for (i = 0; i < lim; ++i)
  74.         { 
  75.             os << ArrayDb::operator[](i) << ' ';
  76.             if (i % 5 == 4)//一行5个数
  77.                 os << '\n';
  78.         }
  79.         if (i % 5 != 0)
  80.             os << std::endl;
  81.     }
  82.     else
  83.         os << "empty array!\n";
  85.     return os;
  86. }
  88. //friends
  89. //输入
  90. std::istream & operator>>(std::istream & is, Student & stu)
  91. { 
  92.     is >> (std::string &)stu;//强制类型转换得到基类对象以调用基类的友元函数operator<<(ostream &, const string &)
  93.     return is;
  94. }
  96. std::istream & getline(std::istream & is, Student & stu)
  97. { 
  98.     getline(is, (std::string &)stu);//由于参数类型，会调用string类的getline函数
  99.     return is;
  100. }
  103. //输出
  104. std::ostream & operator<<(std::ostream & os, const Student & stu)
  105. { 
  106.     os << "Scores for " << (const std::string &)stu << ":\n";//把Student对象转换为string对象，从而使用了string类的友元函数operator<<(std::ostream &, const std::string &)
  107.     //os << stu;//千万别这么写！必须使用显式强制转换，否则一是会导致无限递归调用；
  108.     //二是因为这里是多重继承，两个基类都提供了operator<<函数，编译器不知道该自动转换为哪一个的
  109.     stu.arr_out(os);
  110.     return os;
  111. }
  113. #include <valarray>
  114. #include <iostream>
  115. #include "Studenti.h"
  116. using std::cout;
  117. void set(Student & sa, int n);
  119. int main()
  120. { 
  121.     using std::valarray;
  122.     const int pupils = 3;
  123.     const int quizzes = 5;
  125.     Student ada[pupils] = { Student(quizzes), Student(quizzes), Student(quizzes)};
  126.     for (int i = 0; i < pupils; ++i)
  127.         set(ada[i], quizzes);
  129.     cout << "Student list:\n";
  130.     for (int i = 0; i < pupils; ++i)
  131.         cout << ada[i] << std::endl;
  133.     return 0;
  134. }
  136. void set(Student & sa, int n)
  137. { 
  138.     using std::cin;
  139.     cout << "Enter the student's name: ";
  140.     getline(cin, sa);//Student类的友元函数
  141.     cout << "Enter " << n << " quiz scores:\n";
  142.     for (int i = 0; i < n; ++i)
  143.         cin >> sa[i];//??把对象名当做数组名用？
  144.     //清空输入队列
  145.     while (cin.get() != '\n')
  146.         ;
  147. }

输出

  1. Enter the student's name: aa bb Enter 5 quiz scores: 45 45 45 52 66 Enter the student's name: cc dd
  2. Enter 5 quiz scores:
  3. 78 56 12 46 53 98
  4. Enter the student's name: ee ff
  5. Enter 5 quiz scores:
  6. 78 45 56 23 12
  7. Student list:
  8. Scores for aa bb:
  9. 45 45 45 52 66
  11. Scores for cc dd:
  12. 78 56 12 46 53
  14. Scores for ee ff:
  15. 78 45 56 23 12

保护继承（私有继承的变体）

基类的公有成员和保护成员都成为派生类的保护成员。

保护继承 VS 私有继承

  • 相同：

  1. 基类（第一代类）的接口在派生类（第二代类）都可用。

    • 不同：

  2. 当从派生类再派生一个类时：

私有继承中，第三代类不可以用基类（第一代类）的接口，因为基类的公有方法在派生类（第二代类）已经成为了私有方法。

保护继承中，第三代类还可以使用第一代类的接口。因为第一代类的公有方法（接口）在第二代类中成为了保护方法。

公有继承 VS 保护继承 VS 私有继承

在这里插入图片描述
隐式向上转换implicit upcasting：不需要显式强制类型转换就可以把基类指针或引用指向派生类对象。

重新定义保护派生和私有派生的访问权限（即希望让派生类对象可以在类外部调用基类方法）

由于私有派生和保护派生会使基类的公有方法在派生类成了私有方法或保护方法，在类外部，即外部程序中，不能通过派生类对象调用这些方法（类对象在类外部只能调用公有方法）。那怎么使得这样做变成现实呢？有这么几个办法：

把函数调用包装在另一个函数调用中

即在派生类声明一个同名方法，在实现代码中直接调用基类的该方法

比如，如果想让Student类使用valarray类的sum()方法，则可以给Student类定义一个sum()

  1. double Student::sum() const//Student类的公有方法
  2. { 
  3.     return std::valarray<double>::sum();//调用私有继承得来的私有方法或者保护继承得来的保护方法
  4.     //但是注意这个方法并不是作用于this对象，而是作用于this对象内部包含的valarray对象
  5. }

可以看到，虽然std::valarray::sum()是私有继承得来的私有方法或者保护继承得来的保护方法，但是还是必须用类名限定才就可以访问哦

像名称空间一样，使用using声明指出派生类可以使用基类的特定成员

这种using指令只可以用于继承，不可以用于包含

即使是私有派生，也是可以把通过using指令声明的函数像公有接口那样来使用的

注意using声明写在派生类的公有部分

  1. class Student:private std::string, private std::valarray<double>
  2. { 
  3.     public:
  4.     using std::valarray<double>::max;//只写成员函数名，不写圆括号，特征标以及返回类型
  5.     using std::valarray<double>::min;
  6. }

如果基类有两个同名函数，那么using声明会使得这两个函数都可以像派生类的公有方法一样被使用

发表评论

表情：
评论列表 （有 0 条评论，30人围观）

还没有评论，来说两句吧...

相关阅读