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

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

 

2，根据面向对象理论：

 

    根据 C++ 语法：

  

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

#include <iostream>
#include <string>

using namespace std;

class Parent
{
private:
    int mv;
    
public:
    Parent()
    {
        mv = 100;
    }
    
    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 0;
}

 

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 = 100;
    }
    
    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(50);  
    
    cout << "c.mv = " << c.value() << endl;  // 150;
    
    // c.mv = 10000;   // error，除子类之外的外界不能访问；
    
    return 0;
}

   

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 = 0, int y = 0)
    {
        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(1, 2);
    Point pn(5, 6);
    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 0;
}

 

9，小结：

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

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

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

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

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

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

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