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

Accessors    | Base Class | Derived Class | World
—————————————+————————————+———————————————+———————
public       |      y     |       y       |   y
—————————————+————————————+———————————————+———————
protected    |      y     |       y       |   n
—————————————+————————————+———————————————+———————
private      |            |               |    
  or         |      y     |       n       |   n
no accessor  |            |               |

y: accessible
n: not accessible

基于这个例子的java…我认为一张小桌子胜过千言万语:)

限制继承的可见性将使代码无法看到某些类继承了另一个类:从派生类到基类的隐式转换将不起作用，从基类到派生类的static_cast也将不起作用。

只有类的成员/友元才能看到私有继承，只有类的成员/友元和派生类才能看到受保护继承。

公共继承

是一种继承。一个按钮就是一个窗口，只要需要一个窗口，就可以传递一个按钮。 类按钮:公共窗口{};

保护继承

implemented-in-terms-of保护。很少有用。在boost::compressed_pair中使用从空类派生并使用空基类优化来节省内存(下面的例子没有使用模板来保持在点上): 结构empty_pair_impl: protected empty_class_1 {non_empty_class_2秒;}; 结构对:private empty_pair_impl { Non_empty_class_2 &second() { 返回这个- >第二; ｝ Empty_class_1 &first() { 返回*;//注意我们返回*this! ｝ };

私有继承

Implemented-in-terms-of. The usage of the base class is only for implementing the derived class. Useful with traits and if size matters (empty traits that only contain functions will make use of the empty base class optimization). Often containment is the better solution, though. The size for strings is critical, so it's an often seen usage here template<typename StorageModel> struct string : private StorageModel { public: void realloc() { // uses inherited function StorageModel::realloc(); } };

公共成员

总 类对{ 公众: 首先第一; 第二第二; }; 访问器 类窗口{ 公众: int getWidth(); };

保护成员

提供对派生类的增强访问 类堆栈{ 保护: 矢量c < >元素; }; 类窗口{ 保护: void registerClass(window_descriptor w); };

私有成员

保持实现细节 类窗口{ 私人: int宽度; };

请注意，c风格强制转换有意允许以已定义和安全的方式将派生类强制转换为受保护或私有基类，也可以强制转换为其他方向。无论如何都应该避免这种情况，因为它会使代码依赖于实现细节——但如果有必要，您可以使用这种技术。

Member in base class : Private   Protected   Public   

继承类型:对象继承为:

Private            :   Inaccessible   Private     Private   
Protected          :   Inaccessible   Protected   Protected  
Public             :   Inaccessible   Protected   Public

我发现了一个简单的答案，所以我想把它贴出来，作为我未来的参考。

它来自http://www.learncpp.com/cpp-tutorial/115-inheritance-and-access-specifiers/的链接

class Base
{
public:
    int m_nPublic; // can be accessed by anybody
private:
    int m_nPrivate; // can only be accessed by Base member functions (but not derived classes)
protected:
    int m_nProtected; // can be accessed by Base member functions, or derived classes.
};

class Derived: public Base
{
public:
    Derived()
    {
        // Derived's access to Base members is not influenced by the type of inheritance used,
        // so the following is always true:

        m_nPublic = 1; // allowed: can access public base members from derived class
        m_nPrivate = 2; // not allowed: can not access private base members from derived class
        m_nProtected = 3; // allowed: can access protected base members from derived class
    }
};

int main()
{
    Base cBase;
    cBase.m_nPublic = 1; // allowed: can access public members from outside class
    cBase.m_nPrivate = 2; // not allowed: can not access private members from outside class
    cBase.m_nProtected = 3; // not allowed: can not access protected members from outside class
}

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

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

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之外没有人知道继承。