虚拟基类的演员

Question

我知道这段代码行不通，我也知道原因，但是有替代方法吗？

class A
{
public:
    A(void){}
    virtual ~A(void){}
protected:
    A* parent;
    int a;
};

class B : public virtual A
{
public:
    B(void){}
    virtual ~B(void){}
protected:
    void f(){ ((B*)parent)->a; }
};

不可能将parent 转换为B*，因为A 是一个虚拟基类。不投射 parent 也会产生错误。我希望我不必将所有成员都公开。有人知道如何访问 A::a 吗？

编辑

使用好友不起作用，因为派生自 B 的类无权访问 A::a。

Answer 1

一些选项：

1. 将a公开
2. 为a创建一个公共的setter/getter方法——
3. 让 B 成为 A 类的朋友（或者只是函数 f()）

如果您只想允许 A（或特定函数）访问 A 的成员，则第 3 个选项比其他 2 个更好。另一方面，使用其他 2 个选项，您只能将该成员设为公开（但将对所有人公开）

Answer 2

从我上面的评论中得到答案，因为我测试过它并且编译得很好。

如果没有强制转换，它可能会失败，因为您试图访问 B 中 A 的受保护字段。您只需添加一个公共 getter 并将强制转换删除到 B*

class A
{
public:
    A(void){}
    virtual ~A(void){}
    int getA() { return a; }
protected:
    A* parent;
    int a;
};

class B : public virtual A
{
public:
    B(void){}
    virtual ~B(void){}
protected:
    void f(){ (parent)->getA(); }
};

Answer 3

这行得通：

class A {
public:
    A(void){}
    virtual ~A(void){}
protected:
    A* parent;
    int a;
    int parent_a(){ return parent->a;}
};

class B : public virtual A
{
public:
    B(void){}
    virtual ~B(void){}
protected:
    void f(){ A::parent_a(); }
};

注意：

• a 不暴露于外界，
• 检索到的a 必须是正确的，因为B 实际上继承自A，因此在获得a 字段之前成功将parent 动态转换为B 应该返回相同的如上面提供的解决方案。

现在，为什么这行得通？

因为一个类隐含地是它自己的朋友。

Answer 4

这就是dynamic_cast 的用途。如果您不想重新设计代码，只需将 C 样式转换为 dynamic_cast：

void f() { dynamic_cast<B*>(parent)->a; }

要使其正常工作，A 必须至少具有一个虚函数（就像这个一样）。此外，如果parent 实际上没有指向B 类型的对象，则强制转换将产生一个空指针。

Answer 5

class B : public virtual A
{
public:
    B(void){}
    virtual ~B(void){}
protected:
    void f(){ this->a; }
};

您可以从父类（B 的 A 母类）访问受保护的成员。

Answer 6

我认为这里的问题不在于如何访问元素a，而是为什么在设计中需要一个菱形层次结构树。您应该首先退后一步，评估您是否真的需要一颗钻石树。

如果您这样做，那么代替您当前的方法，为A 提供一个可以从B 调用的合适的（公共）抽象接口。当您开始直接访问受保护的父属性时，您将组件紧密耦合在一起，从而很容易破坏您的代码，并且很难在应用程序生命周期的后期更改您的设计。

Answer 7

谢谢大家，我们提到了一些可用的可能性，比如使用朋友和为每个变量创建附加函数。这可能在某些情况下有效，但不适用于我的情况。将每个派生类添加为朋友存在的问题是，当他们想要添加一个类时，它会使库的用户友好性降低。为每个变量添加函数会为某些类添加上百个额外函数。

作为我的最终解决方案，我所做的是创建副本而不是演员表。虽然它会运行一点点慢，代码将保持干净。解决速度问题。访问局部变量比访问全局变量快很多。

这就是现在的样子：

class A
{
public:
    A* parent;
    virtual ~A(void){}
    virtual A & operator = (const A & x)
    {
        a = x.a;
        parent = x.parent;
        return *this;
    }
protected:
    int a;
};

class B : public virtual A
{
public:
    B(void){}
    virtual ~B(void){}
    using A::operator =;
    virtual B & operator = (const B & x)
    {
        A::operator = (x);
        return *this;
    }
    void f(void)
    {
        B p;
        p = *parent;
        int x = p.a;//Allowed.
    }
};

如果您有更好的解决方案，请随时发布。