C++深度解析(34)—继承中的访问级别

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接: https://blog.csdn.net/qq_22847457/article/details/96869738

1.值得思考的问题

  • 子类是否可以直接访问父类的私有成员?
    • 根据面向对象的理论:子类拥有父类的一切属性和行为,子类能够直接访问父类的私有成员!
    • 但C++语法规定,外界不能直接访问类的private成员,所以子类也不能直接访问父类的私有成员

 
  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4. class Parent
  5. {
  6. private:
  7. int mv;
  8. public:
  9. Parent()
  10. {
  11. mv = 100;
  12. }
  13. int value()
  14. {
  15. return mv;
  16. }
  17. };
  18. class Child : public Parent
  19. {
  20. public:
  21. int addValue(int v)
  22. {
  23. mv = mv + v; // error如何访问父类的非公有成员
  24. return mv;
  25. }
  26. };
  27. int main()
  28. {
  29. return 0;
  30. }

2.继承中的访问级别

  • 面向对象中的访问级别不只是publicprivate,可以定义protected访问级别
  • 关键字protected的意义
    • 修饰的成员不能被外界直接访问
    • 修饰的成员可以被子类直接访问
  • 原则:
    • 需要被外界访问的成员直接设置为public
    • 只能在当前类中访问的成员设置为private
    • 只能在当前类和子类中访问的成员设置为protected
    • private成员在子类中依然存在,但是却无法访问到

3.编程实验

  • protected初体验   

 
  1. #include<iostream>
  2. using namespace std;
  3. class Parent
  4. {
  5. protected:
  6. int mv;
  7. public:
  8. Parent()
  9. {
  10. mv = 100;
  11. }
  12. int value()
  13. {
  14. return mv;
  15. }
  16. };
  17. class Child : public Parent
  18. {
  19. public:
  20. int addValue(int v)
  21. {
  22. mv = mv + v;
  23. return mv;
  24. }
  25. };
  26. int main()
  27. {
  28. Parent p;
  29. cout << "p.mv = " << p.value() << endl;
  30. Child c;
  31. cout << "c.mv = " << c.value() << endl;
  32. c.addValue( 50);
  33. cout << "c.mv = " << c.value() << endl;
  34. system( "pause");
  35. return 0;
  36. }
  • ​​​​​​​  运行结果:

4.组合和继承的综合实例

  • Point,Line与Object是继承关系,Point和Line是组合关系

 
  1. #include<iostream>
  2. #include<sstream>
  3. using namespace std;
  4. class Object
  5. {
  6. protected:
  7. string mName;
  8. string mInfo;
  9. public:
  10. Object()
  11. {
  12. mName = "object";
  13. mInfo = "";
  14. }
  15. string name()
  16. {
  17. return mName;
  18. }
  19. string info()
  20. {
  21. return mInfo;
  22. }
  23. };
  24. class Point : public Object
  25. {
  26. private:
  27. int mX;
  28. int mY;
  29. public:
  30. Point( int x = 0, int y = 0)
  31. {
  32. ostringstream s;
  33. mX = x;
  34. mY = y;
  35. mName = "Point";
  36. s << "P(" << mX << "," << mY << ")";
  37. mInfo = s.str();
  38. }
  39. int x()
  40. {
  41. return mX;
  42. }
  43. int y()
  44. {
  45. return mY;
  46. }
  47. };
  48. class Line : public Object
  49. {
  50. private:
  51. Point mP1;
  52. Point mP2;
  53. public:
  54. Line(Point p1, Point p2)
  55. {
  56. ostringstream s;
  57. mP1 = p1;
  58. mP2 = p2;
  59. mName = "Line";
  60. s << "Line from " << mP1.info() << "to" << mP2.info();
  61. mInfo = s.str();
  62. }
  63. Point begin()
  64. {
  65. return mP1;
  66. }
  67. Point end()
  68. {
  69. return mP2;
  70. }
  71. };
  72. int main()
  73. {
  74. Object o;
  75. Point p(1, 2);
  76. Point pn(5, 6);
  77. Line l(p, pn);
  78. cout << o.name() << endl;
  79. cout << o.info() << endl;
  80. cout << endl;
  81. cout << p.name() << endl;
  82. cout << p.info() << endl;
  83. cout << endl;
  84. cout << l.name() << endl;
  85. cout << l.info() << endl;
  86. system( "pause");
  87. return 0;
  88. }

运行结果

  • 组合和继承,都是类之间的一种关系。只不过在性质和使用方式上存在不同。、

5.小结

  • 面向对象中的访问级别不只有publicprivate
  • protected修饰的成员不能被外界所访问
  • protected使得子类能够访问父类的成员
  • protected关键字是为了继承而专门设计的
  • 没有protected就无法完成真正意义上的代码复用
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页