"super"关键字的 c++ 仿真

Question

在用 c++ 实现“super”之前，我正在寻找一种自己模拟它的方法。动机:这是一个典型的场景:

class A
{
    void SomeMethod();
}

class B : public A
{
    void SomeMethod() override;
}

void B::DoSomething()
{
    A::SomeMethod();
}

一切都很好，直到有人在两者之间插入一个类:

class C : public A
{
    void SomeMethod() override;
}

并改变继承:

class B : public C {...}

在大多数情况下，我希望直接基类被调用，这不会发生，除非我明确地将所有 A::调用替换为 C::调用。

“super”关键字在这里会有很大用处，它的意思是:“使用直接基数，但如果不明确则发出编译器错误”。

阅读一些建议，我尝试定义如下:

class A
{
    void SomeMethod();

    protected:
        using super = A;
}

class C
{
    void SomeMethod();

    protected:
        using super = C;
}

void B::DoSomething()
{
    super::SomeMethod();
}

但是调用了 A::SomeMethod() 而不是 C::SomeMethod()...

编译器如何处理同名的多个别名？

我该如何解决这个问题？

编辑:建议的其他问题是一个旧问题，解决方案可以通过使用现代 c++ 进行改进。

Answer 1

解决此问题的一种方法是将其设为模板，但它确实限制了您使用该类的方式。通过这样做，您可以使基类成​​为模板类型，现在您可以使用通用名称来引用它们。看起来像

struct A
{
    void do_something() { std::cout << "A::do_something\n"; }
};

template <typename Super>
struct B : Super
{
    void do_something() 
    { 
        std::cout << "B::do_something\n"; 
        Super::do_something(); 
    }
};

template <typename Super>
struct C : Super
{
    void do_something() 
    { 
        std::cout << "C::do_something\n"; 
        Super::do_something(); 
    }
};

int main() 
{
    B<A> b;
    b.do_something();
    C<B<A>> c;
    c.do_something();
}

哪些输出

B::do_something
A::do_something
C::do_something
B::do_something
A::do_something

您甚至可以使用多重继承并单独访问每个基础

template <typename Super1, typename Super2>
struct B : Super1, Super2
{
    void do_something() 
    { 
        std::cout << "B::do_something\n"; 
        Super1::do_something(); 
        Super2::do_something(); 
    }
};