C++中继承的protected访问级别

1，子类是否可以直接访问父类的私有成员？

2，根据面向对象理论：

根据 C++ 语法：

3，继承中的访问级别编程实验：

 #include <iostream>
 #include <string>

 using namespace std;

 class Parent
 {
 private:
     int mv;

 public:
     Parent()
     {
         mv = ;
     }

     int value()
     {
         return mv;
     }
 };

 class Child : public Parent  // Child 虽然是 Parent 的子类，但是严格意义上来说，它绝对是 Parent 的外部，因此 Parent 不可以访问 Parent 类的私有成员；
 {
 public:
     int addValue(int v)
     {
         mv = mv + v;    // 这里访问了两次 mv，编译器则显示了两次编译错误，在同一个地方；如何访问父类的非公有成员？
     }
 };

 int main()
 {
     return ;
 }

4，继承中的访问级别：

1，面向对象中的访问级别不只是 public 和 private：

2，可以定义 protected 访问级别；

3，关键字 protected 的意义；

1，修饰的成员不能被外界直接访问；

2，修饰的成员可以被子类直接访问；

5，protected 初体验编程实验：

 #include <iostream>
 #include <string>

 using namespace std;

 class Parent
 {
 protected:
     int mv;
 public:
     Parent()
     {
         mv = ;
     }

     int value()
     {
         return mv;
     }
 };

 class Child : public Parent
 {
 public:
     int addValue(int v)
     {
         mv = mv + v;
     }
 };

 int main()
 {
     Parent p;

     cout << "p.mv = " << p.value() << endl;  // 100;

     // p.mv = 1000;    // error，除子类之外的外界不能访问；

     Child c;

     cout << "c.mv = " << c.value() << endl;  // 100；

     c.addValue();  

     cout << "c.mv = " << c.value() << endl;  // 150;

     // c.mv = 10000;   // error，除子类之外的外界不能访问；

     return ;
 }

6，为什么面向对象中需要 protected ？

1，所有的开发者应该都有一个架构师德梦想，架构师需要具备的一个素质就是设计能力，我们在做开发的时候，也许系统需要这个功能、也许不需要，究竟需不需要呢？一个系统中并不是功能越多越好，因此我们必须要有设计能，学习过程中要多思考；

2，从生活中入手来思考，女孩子整容否、男孩子尿床、同性恋否，这些信息就是 private 的，生活中的工资是隐私，但是家人可以知道，这是就是 protected；

3，protected 的引入是必须的、绝对的，没有它的引入，面向对象就是不完善的；

4，其他的面向对象语言中如 Java、C# 等，它们当中的访问权限不止三种；

7，定义类时访问级别的选择：

1，左右分支的不同之处在于，是否会被继承，这也是 protected 选择与否的根本依旧；

8，组合与继承的综合实例：

1，这张图中 Object 这个类就是用来被继承的；

2，Line 这个类组合了 Point 这个类；

3，综合实例编程实验：

 #include <iostream>
 #include <string>
 #include <sstream>

 using namespace std;

 class Object  // 就是用来被继承的；
 {
 protected:  // 就是被继承
     string mName;
     string mInfo;

 public:
     Object()
     {
         mName = "Object";
         mInfo = "";
     }

     string name()
     {
         return mName;
     }

     string info()
     {
         return mInfo;
     }
 };

 class Point : public Object  // 点这个类不需要被继承；
 {
 private:
     int mX;
     int mY;

 public:
     Point(int x = , int y = )
     {
         ostringstream s;

         mX = x;
         mY = y;
         mName = "Point";

         s << "P(" << mX << ", " << mY << ")";

         mInfo = s.str();
     }

     int x()
     {
         return mX;
     }

     int y()
     {
         return mY;
     }
 };

 class Line : public Object  // 不会被继承；
 {
 private:
     Point mP1;
     Point mP2;

 public:
     Line(Point p1, Point p2)  // 这里编译错误，因为要调用默认构造函数，但是 Point 已经定义了构造函数，此刻可以采用赋默认值的方式；
     {
         ostringstream s;

         mP1 = p1;
         mP2 = p2;
         mName = "Line";

         s << "Line from " << mP1.info() << " to " << mP2.info();

         mInfo = s.str();
     }

     Point begin()
     {
         return mP1;
     }

     Point end()
     {
         return mP2;
     }
 };

 int main()
 {
     Object o;
     Point p(, );
     Point pn(, );
     Line l(p, pn);

     cout << o.name() << endl;  // 单元测试；Object
     cout << o.info() << endl;  // 单元测试；“ ”

     cout << endl;

     cout << p.name() << endl;  // 单元测试；Point
     cout << p.info() << endl;  // 单元测试；p(1, 2)

     cout << endl;

     cout << l.name() << endl;  // Line
     cout << l.info() << endl;  // Line from p(1, 2) to p(5, 6)

     return ;
 }

9，小结：

1，面向对象中的访问级别不只是 public 和 private；

2，protected 修饰的成员不能被外界所访问；

3，protected 使得子类能够访问父类的成员；

1，子类继承父类后，子类和父类中相同的代码各有一套，分别存储使用的。

4，protected 关键字是为了继承而专门设计的；

5，没有 protected 就无法完成真正意义上的代码复用；

1，因为 private 不能继承，而 public 不用继承，但是有些信息又是介乎两者之间的；