简介:

Private:除了类内部，没有人可以看到它 Protected: Private +派生类可以看到它 公众:全世界都能看到

在继承时，你可以(在某些语言中)在某个方向上改变数据成员的保护类型，例如从protected变为public。

它本质上是派生类中基类的公共和受保护成员的访问保护。通过公共继承，派生类可以看到基类的公共成员和受保护成员。而私有继承则不能。使用protected，派生类及其派生的任何类都可以看到它们。

为了回答这个问题，我想先用我自己的话描述一下成员的访问器。如果你已经知道这一点，那就跳到标题“下一步:”。

我知道有三种访问器:公共的、受保护的和私有的。

Let:

class Base {
    public:
        int publicMember;
    protected:
        int protectedMember;
    private:
        int privateMember;
};

所有知道Base的都知道Base包含publicMember。 只有子节点(及其子节点)知道Base包含protectedMember。 除了Base，没有人知道privateMember。

“意识到”，我的意思是“承认存在，从而能够获得”。

下一个:

同样的情况也发生在公共、私有和受保护的继承上。让我们考虑一个类Base和一个继承自Base的类Child。

如果继承是公共的，那么所有知道Base和Child的东西也知道Child从Base继承。 如果继承是受保护的，那么只有Child及其子元素知道它们从Base继承。 如果继承是私有的，那么除了Child之外没有人知道继承。

任何继承自您的类的类都可以访问受保护的数据成员。但是，私有数据成员不能。假设我们有以下内容:

class MyClass {
    private:
        int myPrivateMember;    // lol
    protected:
        int myProtectedMember;
};

从扩展到这个类，引用这个。myPrivateMember不能工作。然而,这。myProtectedMember意志。这个值仍然是封装的，所以如果我们有一个myObj类的实例化，那么myObj。myProtectedMember不能工作，所以它的功能类似于私有数据成员。

我试着用下面的一张图片来解释继承。

主要的要点是父类的私有成员永远不能从派生类/子类直接访问，但是您可以使用父类的成员函数来访问父类的私有成员。 私有变量始终存在于派生类中，但派生类不能访问它。这就像他们的，但你不能用自己的眼睛看到，但如果你问一个来自父母类的人，然后他可以向你描述。

这三个关键字还在完全不同的上下文中用于指定可见性继承模型。

这个表收集了组件声明和继承模型的所有可能组合，表示在子类完全定义后对组件的最终访问。

上表的解释如下(看第一行):

如果一个组件被声明为公共的，并且它的类被继承为公共的，那么得到的访问是公共的。

一个例子:

 class Super {
    public:      int p;
    private:     int q;
    protected:   int r;
 };

 class Sub : private Super {};

 class Subsub : public Sub {};

Subsub类中变量p, q, r的访问结果为none。

另一个例子:

class Super {
    private:     int x;
    protected:   int y;
    public:      int z;
 };
class Sub : protected Super {};

类Sub中对变量y, z的访问受到保护，对变量x的访问为none。

一个更详细的例子:

class Super {
private:
    int storage;
public:
    void put(int val) { storage = val;  }
    int  get(void)    { return storage; }
};
int main(void) {
    Super object;

    object.put(100);
    object.put(object.get());
    cout << object.get() << endl;
    return 0;
}

现在让我们定义一个子类:

class Sub : Super { };

int main(void) {
    Sub object;

    object.put(100);
    object.put(object.get());
    cout << object.get() << endl;
    return 0;
}

定义了一个名为Sub的类，它是一个名为Super的类的子类，或者这个子类是从Super类派生的。 子类既不引入新变量也不引入新函数。这是否意味着子类的任何对象都继承了父类之后的所有特征，实际上是父类对象的副本?

不。它不是。

如果我们编译下面的代码，我们只会得到编译错误，表示put和get方法不可访问。为什么?

当省略可见性说明符时，编译器假定我们将应用所谓的私有继承。这意味着所有的公共超类组件都变成了私有访问，私有超类组件将根本无法访问。因此，这意味着不允许在子类中使用后者。

我们必须通知编译器我们想要保留以前使用的访问策略。

class Sub : public Super { };

不要被误导:这并不意味着私人组件的超 类(如存储变量)将转换为公共类 有点神奇。私有组件将保持私有、公开 将继续公开。

子类的对象可以做“几乎”与从超类创建的它们的哥哥姐姐相同的事情。“几乎”是因为作为子类的事实也意味着该类失去了对超类的私有组件的访问权。子类的成员函数不能直接操作存储变量。

这是一个非常严重的限制。有什么解决办法吗?

Yes.

第三个访问级别称为受保护。关键字protected意味着标记了它的组件在被任何子类使用时表现得像一个公共组件，而对其他组件看起来像一个私有组件。——这只适用于公共继承的类(比如我们例子中的Super类)——

class Super {
protected:
    int storage;
public:
    void put(int val) { storage = val;  }
    int  get(void)    { return storage; }
};

class Sub : public Super {
public:
    void print(void) {cout << "storage = " << storage;}
};

int main(void) {
    Sub object;

    object.put(100);
    object.put(object.get() + 1);
    object.print();
    return 0;
}

正如你在示例代码中看到的，我们给子类添加了一个新功能，它做了一件重要的事情:它从超类访问存储变量。

如果变量被声明为私有，这是不可能的。 在main函数的作用域中，变量仍然是隐藏的，所以如果你这样写:

object.storage = 0;

编译器会告诉你这是一个错误:'int Super::storage'是受保护的。

最后，最后一个程序将产生以下输出:

storage = 101