我只是找到了一个替代方案。我有一个大问题与类型定义方法今天咬我:

类型定义需要类名的精确副本。如果有人改变了类名，但没有改变类型定义，那么你就会遇到问题。

所以我用一个非常简单的模板想出了一个更好的解决方案。

template <class C>
struct MakeAlias : C
{ 
    typedef C BaseAlias;
};

所以现在，不是

class Derived : public Base
{
private:
    typedef Base Super;
};

你有

class Derived : public MakeAlias<Base>
{
    // Can refer to Base as BaseAlias here
};

在本例中，BaseAlias不是私有的，我已经尝试通过选择一个应该提醒其他开发人员的类型名称来防止粗心使用。

在从Turbo Pascal迁移到c++之后，我曾经这样做是为了有一个等效的Turbo Pascal“inherited”关键字，它以相同的方式工作。然而，在用c++编程了几年之后，我就不再这么做了。我发现我不是很需要它。

我在许多代码库中都看到过这个习语，我很确定我甚至在Boost的库中看到过它。然而，据我所知，最常见的名称是base(或base)而不是super。

这种习惯用法在处理类模板时特别有用。作为一个例子，考虑下面的类(来自一个真实的项目):

template <typename TText, typename TSpec>
class Finder<Index<TText, PizzaChili<TSpec>>, MyFinderType>
    : public Finder<Index<TText, MyFinderImpl<TSpec>>, Default>
{
    using TBase = Finder<Index<TText, MyFinderImpl<TSpec>>, Default>;
    // …
}

继承链使用类型参数来实现编译时多态性。不幸的是，这些模板的嵌套级别非常高。因此，完整类型名的有意义的缩写对于可读性和可维护性至关重要。

微软已经在他们的编译器中添加了__super的扩展。

我不会说太多，除了目前的代码注释，说明super并不意味着调用base!

超级!=基本。

简而言之，“超级”到底是什么意思?那么"base"是什么意思呢?

Super表示调用方法的最后一个实现者(不是基方法) 基是指在多重继承中选择哪个类是默认基。

这两条规则适用于类的typedefs。

考虑库的实现者和库的用户，谁是超级谁是基础?

更多信息，这里是工作代码复制粘贴到您的IDE:

#include <iostream>

// Library defiens 4 classes in typical library class hierarchy
class Abstract
{
public:
    virtual void f() = 0;
};

class LibraryBase1 :
    virtual public Abstract
{
public:
    void f() override
    {
        std::cout << "Base1" << std::endl;
    }
};

class LibraryBase2 :
    virtual public Abstract
{
public:
    void f() override
    {
        std::cout << "Base2" << std::endl;
    }
};

class LibraryDerivate :
    public LibraryBase1,
    public LibraryBase2
{
    // base is meaningfull only for this class,
    // this class decides who is my base in multiple inheritance
private:
    using base = LibraryBase1;

protected:
    // this is super! base is not super but base!
    using super = LibraryDerivate;

public:
    void f() override
    {
        std::cout << "I'm super not my Base" << std::endl;
        std::cout << "Calling my *default* base: " << std::endl;
        base::f();
    }
};

// Library user
struct UserBase :
    public LibraryDerivate
{
protected:
    // NOTE: If user overrides f() he must update who is super, in one class before base!
    using super = UserBase; // this typedef is needed only so that most derived version
    // is called, which calls next super in hierarchy.
    // it's not needed here, just saying how to chain "super" calls if needed

    // NOTE: User can't call base, base is a concept private to each class, super is not.
private:
    using base = LibraryDerivate; // example of typedefing base.

};

struct UserDerived :
    public UserBase
{
    // NOTE: to typedef who is super here we would need to specify full name
    // when calling super method, but in this sample is it's not needed.

    // Good super is called, example of good super is last implementor of f()
    // example of bad super is calling base (but which base??)
    void f() override
    {
        super::f();
    }
};

int main()
{
    UserDerived derived;
    // derived calls super implementation because that's what
    // "super" is supposed to mean! super != base
    derived.f();

    // Yes it work with polymorphism!
    Abstract* pUser = new LibraryDerivate;
    pUser->f();

    Abstract* pUserBase = new UserBase;
    pUserBase->f();
}

这里还有一点很重要:

多态呼叫:向下呼叫 超级呼叫:向上呼叫

在main()内部，我们向下使用多态调用，而super向上调用，这在实际生活中并不是很有用，但它说明了两者的区别。

这样做的一个问题是，如果你忘记(重新)为派生类定义super，那么任何对super::的调用都可以编译，但可能不会调用想要的函数。

例如:

class Base
{
public:  virtual void foo() { ... }
};

class Derived: public Base
{
public:
    typedef Base super;
    virtual void foo()
    {
        super::foo();   // call superclass implementation

        // do other stuff
        ...
    }
};

class DerivedAgain: public Derived
{
public:
    virtual void foo()
    {
        // Call superclass function
        super::foo();    // oops, calls Base::foo() rather than Derived::foo()

        ...
    }
};

(正如Martin York在对这个答案的评论中指出的，这个问题可以通过将类型定义为private而不是public或protected来消除。)