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

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

EDIT2:

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

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

private:
    int a;
};
Martin Drozdik asked 2019-10-09T08:08:35Z
4个解决方案
71 votes

即使C ++中的访问控制按类(而不是按实例)工作,但b.somethingProtected()访问说明符还是有一些特殊之处。

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

因此,您必须通过2561391274226096098语法,BaseBase *语法访问受保护的成员,其中指针/引用/对象引用派生类。

这意味着在您的示例中,不能通过Base对象,Base *指针或Base &引用访问受保护成员b.somethingProtected(),但是可以通过Derived对象,Derived *指针和Derived &引用访问受保护成员。 允许使用普通的somethingProtected()访问权限,因为这只是this->somethingProtected()的简写形式,其中this的类型为Derived *

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

请注意,按照上述规则

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

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

AnT answered 2019-10-09T08:09:30Z
3 votes

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

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
>     }
Dory Zidon answered 2019-10-09T08:10:53Z
2 votes

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

Chris Dodd answered 2019-10-09T08:11:20Z
1 votes

您所做的事情在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.
    }
};
Deepu answered 2019-10-09T08:11:50Z
translate from https://stackoverflow.com:/questions/16785069/why-cant-a-derived-class-call-protected-member-function-in-this-code