68 
#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;
};
4

4 回答 4

84

尽管 C++ 中的访问控制是基于每个类（而不是基于每个实例）工作的，但protected访问说明符有一些特殊性。

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

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

这意味着在您的示例中，受保护的成员somethingProtected()不能通过Base对象、Base *指针或Base &引用访问，但可以通过Derived对象、Derived *指针和Derived &引用访问。允许您的普通somethingProtected()访问，因为它只是this->somethingProtected()where thisis of type的简写Derived *。

b.somethingProtected()违反上述要求。

注意按照上面的规则在

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

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

于 2013-05-28T06:28:49.073 回答
3

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

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

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

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

事实上，从另一个实例成员或主函数访问另一个类的受保护成员实际上都是在公共访问之下......

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
>     }
于 2013-05-28T06:19:04.303 回答
2

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

于 2013-05-28T06:28:19.937 回答
1

你所做的在 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.
    }
};
于 2013-05-28T06:33:14.693 回答