Question

我有以下结构，我想从D打电话给foo。怎么可能？我收到了错误消息，我在下面的一行评论过。

class A
{
protected:
    class B
    {
    public:
        B(x)
        {
            //...
        }

    protected:
        virtual void foo()
        {
            //...
        }
    };
};

class C : public A
{
protected:
    class D : public A::B
    {
    public:
        D(x) : B(x)
        {
            //empty
        }
    };

    void bar()
    {
        D var = D(x);
        var.foo(); //cant access protected member in class A::B
    }
};

Answer 1

foo（）是B的受保护成员函数，意味着只允许从其子类（子类）调用foo（）。

bar（）是C的成员函数，C是A的继承。因此，C不是B的子类。

如果你把bar放在D中，那就OK了。如下面的代码：

class A
{
protected:
    class B
    {
    public:
        B(int x)
        {
            //...
        }

    protected:
        virtual void foo()
        {
            //...
        }
    };
};

class C : public A
{
protected:
    class D : public A::B
    {
    public:
        D(int x) : B(x)
        {
            //empty
        }

        // Here is OK, while D is subclass of B
        void bar()
        {
            int x;
            D var = D(x);
            var.foo(); //cant access protected member in class A::B
        }
    };

    // void bar()
    // {
    //     int x;
    //     D var = D(x);
    //     var.foo(); //cant access protected member in class A::B
    // }
};


int main(){


    return 0;
}

Answer 2

您可能希望foo()在D中公开，即使它在A::B

中受到保护

如果是这样，您可以在public:

定义中的D行之后添加以下行

using A::B::foo;

Answer 3

尝试一下朋友班。你可以让D成为B的朋友，这应该允许D调用foo（）。

Answer 4

实际上，您尝试从班级C访问类D ==＆gt;的受保护方法您不能从类外部访问受保护的方法。

一种解决方案可能是将C声明为D的朋友类，以便C可以访问受保护的方法：

// ...

    class D : public A::B
    {
    public:
        D(x) : B(x)
        {
            //empty
        }

        // Declare C as friend of D
        friend class C;
    };

// ...

添加友情声明，您的代码将编译并按预期工作。

Answer 5

感谢您的回答。使foo函数公开是一个真正的解决方案，但我真的希望foo只能从继承类中获得。朋友修饰符是一个很多人讨厌的东西，因为它可以让你访问你不应该访问的内容。

但你也是对的，我应该从D访问B :: foo（从构造函数不是一个选项是我的情况）。我可以创建一个调用原始foo的函数，所以我的解决方案是：

class A
{
protected:
    class B
    {
    public:
        B(x)
        {
            //...
        }

    protected:
        virtual void foo()
        {
            //...
        }
    };
};

class C : public A
{
protected:
    class D : public A::B
    {
    public:
        D(x) : B(x)
        {
            //empty
        }

        Dfoo()
        {
            B::foo();
        }
    };

    void bar()
    {
        D var = D(x);
        var.Dfoo();
    }
};

解决方案很简单，但我不知道可以像这样调用一个函数（什么不是静态的）:)

类方法继承中的C ++类

5 个答案: