为什么派生类不能在此代码中调用受保护的成员函数？

Question

#include <iostream>

class Base
{  
protected:
    void somethingProtected()
    {
        std::cout << "lala" << std::endl;
    }
};

class Derived : public Base
{
public:
    void somethingDerived()
    {
        Base b;
        b.somethingProtected();    // This does not compile
        somethingProtected();      // But this is fine
    }
};

int main()
{
    Derived d;
    d.somethingDerived();
    return 0;
}

我认为也许只能使用this受保护成员，而其他实例的受保护成员永远无法访问。

但：

class Derived : public Base
{
public:

    void somethingDerived(Derived& d)
    {
        d.somethingProtected();  // This compiles even though d is
                                 // potentially a different instance
    }

    void somethingDerived(Base& b)
    {
        b.somethingProtected();  // This does not
    }
};

因为我已经用C ++编程一段时间了，所以我对此感到有点恶心，但是我找不到这种行为的任何解释。

编辑：

相同或不同的实例无关紧要：

int main()
{
    Derived d1, d2;          // Two different instances
    d1.somethingDerived(d2); // This compiles fine
    d1.somethingDerived(d1); // This compiles fine
    return 0;
}

编辑2：

看来，在访问权限方面，使用什么类的实例根本不重要：

class Base
{
public:
    void something(Base& b)  // Another instance
    {
        ++b.a;               // But can enter private members
    }

private:
    int a;
};

Answer 1

即使C ++中的访问控制基于每个类（而不是基于每个实例）进行工作，但是protected访问说明符仍具有某些特殊性。

语言规范希望确保您正在访问属于派生类的某些基础子对象的受保护成员。 您不应该能够访问某些基本类型无关的独立对象的受保护成员。 特别是，您不能访问基本类型的独立对象的受保护成员。 仅允许您访问嵌入到派生对象中作为基础子对象的基础对象的受保护成员。

因此，您必须通过pointer->member语法， reference.member或object.member语法访问受保护的成员，其中指针/引用/对象引用派生类。

这意味着在您的示例中，受保护的成员somethingProtected()不能通过Base对象， Base *指针或Base &引用访问，但是可以通过Derived对象， Derived *指针和Derived &引用访问。 你的普通somethingProtected()的访问是允许的，因为它仅仅是一个速记this->somethingProtected()其中this是类型的Derived * 。

b.somethingProtected()违反了以上要求。

请注意，按照上述规则

void Derived::somethingDerived()
{
    Base *b = this;
    b->somethingProtected();    // ERROR
    this->somethingProtected(); // OK
}

即使两者都试图访问同一实体，第一个调用也将失败，而第二个将编译。

Answer 2

我相信您对如何访问基类成员有些困惑。 只有这样：

class Derived : public Base
void drivedMethod() {
    Base::baseMethod();
}

在您的示例中，您尝试访问另一个实例的受保护成员。

一个派生实例将有权访问其自己的受保护成员，但不能访问另一个类实例受保护的成员，这是设计使然。

实际上，从另一个实例成员或从main函数访问另一个类的受保护成员实际上都处于公共访问权限下。

http://www.cplusplus.com/doc/tutorial/inheritance/ （查找访问说明符表以查看不同的级别）

这两个例子证明了同一件事，例如：

void somethingDerived(Base& b)
    {
        b.somethingProtected();  // This does not

在这里，您的Derived类将b作为参数，因此它正在获取base的另一个实例，然后由于b.somethingProtected不是公共的，因此将不符合要求。

这将包括：

void somethingDerived()
{
   Base::somethingDerived();

您的第二个示例合规性很好，因为您正在访问另一个d类上的公共方法

>  void somethingDerived(Base& b)
>     {
>         b.somethingProtected();  // This does not
>     }

Answer 3

Derived类只能访问Derived对象中受保护的基本成员。 它不能访问不是（不一定） Derived对象的对象中的成员。 在失败的情况下，您尝试通过Base &来访问成员，并且由于这可能引用的对象不是Derived ，因此无法进行访问。

Answer 4

您所做的事情在C ++中是非法的。 类的对象不能访问受保护的成员。 只有成员函数才能访问受保护的成员。 protected成员的行为与私有成员的行为相同，只是由派生类继承的成员除外。 考虑下面给出的程序，以了解私人，公共和受保护成员之间的区别。

class Base
{
    private:
    void somethingPrivate()
    {
        std::cout << "sasa" << std::endl;
    }
    public:
    void somethingPublic()
    {
        std::cout << "haha" << std::endl;
    }
    protected:
    void somethingProtected()
    {
        std::cout << "lala" << std::endl;
    }
};

class Derived : public Base
{
public:
    void somethingDerived()
    {
       Base b;
       b.somethingPublic();   // Works fine.
       somethingProtected();  // This is also fine because accessed by member function.
       //b.somethingProtected();  // Error. Called using object b.
       //somethingPrivate();      // Error. The function is not inherited by Derived.
    }
};