Question

我有一个类树：

class A;
class B : public A;

然后我想创建一个派生自B类的类。但我希望从外部成员以及从C类继承的其他任何人隐藏该派生

class C : private B;

void test() {
    C c;
    B *b = &c; // compiler error: B in C is private and is therefore not type compatible. This is desired.
}

但是，我还想揭示A类的继承。在这种情况下隐藏B类也会隐藏A类。

void test2() {
    C c;
    A *a = &c; // Compiler error: A is only accessible through B which is not possible with a private inheritance of B. This is not desired; this conversion should be possible.
}

我可以再次从A继承，但如果A有任何，那么显然会创建重复的成员变量。我可以创建A类的虚拟继承，但是我觉得它不会产生我想要的确切效果，因为这会影响整个树而不是这个段（对吧？）

我认为显而易见的解决方案是创建一个类型转换成员函数：

class C : private B {
    A * turn_into_A() {
        // Since B is an A and we are still in the scope of C, this will succeed
        return this;
    }
};

但是，我更愿意避免使用明确的类型转换，例如

任何理智的人都可能告诉我，我做错了。他们可能是对的。但我想知道的仅仅是为了知识：有没有办法在没有虚拟继承或明确的成员函数的类型转换的情况下做到这一点？

Answer 1

我找到了一个可行的解决方案：

class A {
public:
    void somethingA() {
        std::cout << "a" << std::endl;
        return;
    }
 };
class B :
    public A {
public:
    void somethingB() {
        std::cout << "b" << std::endl;
        return;
    }
};
class C :
    private B {
public:
using B::A; // While B is private (and hidden), this exposes access to B::A
    void somethingC() {
        std::cout << "c" << std::endl;
        return;
    }
};

int main(int argc, char **argv) {
    C c;
    B* b = &c; // Compiler error: cannot convert because B is private (desired)
    A* a = &c; // Okay! (required)
    c.somethingC();
    c.somethingB(); // Compiler error: private. (desired)
    c.somethingA(); // Compiler error: A is exposed, but not A's members. This can be solved by adding 'using B::A::somethingA()' in class declaration (undesired but acceptable in my situation)
    a->somethingA(); // Okay! (of course)
}

它并不完美，因为它只能暴露C才能转换为A（为了我的目的，无论如何我最终会做的，所以没关系）。但是它没有直接暴露A的成员以允许C被用作-A，例如你不能调用c :: somethingA（），除非你特别暴露B :: A :: somethingA。

Answer 2

继承描述了IS-A关系。所以，在你的对象模型中，B IS-A A，C IS-A B.所以，你为什么不使用

class C : public B { ...};

这样您就可以根据需要将C对象视为B对象以及A对象。希望有所帮助。

部分隐藏的继承树

2 个答案: