为什么c++不支持“super”关键字的简单答案是。

DDD(死亡之钻)问题。

在多重继承中。编译器会混淆哪个是超类。

那么哪个超类是D的超类呢??“Both”不能是解决方案，因为“super”关键字是指针。

我经常看到它被使用，有时作为super_t，当基类是一个复杂的模板类型时(例如boost::iterator_adaptor就是这样做的)

我试图解决这个完全相同的问题;我抛出了一些想法，比如使用可变模板和包扩展来允许任意数量的父元素，但我意识到这将导致像“super0”和“super1”这样的实现。我把它扔了，因为那只会比一开始就没有它有用多少。

我的解决方案涉及一个辅助类PrimaryParent，实现如下:

template<typename BaseClass>
class PrimaryParent : virtual public BaseClass
{
protected:
    using super = BaseClass;
public:
    template<typename ...ArgTypes>
    PrimaryParent<BaseClass>(ArgTypes... args) : BaseClass(args...){}
}

然后你想要使用的类将被这样声明:

class MyObject : public PrimaryParent<SomeBaseClass>
{
public:
    MyObject() : PrimaryParent<SomeBaseClass>(SomeParams) {}
}

为了避免在PrimaryParenton BaseClass中使用虚拟继承，使用一个接受可变数量参数的构造函数来允许构造BaseClass。

BaseClass的公共继承到PrimaryParent的原因是让MyObject对BaseClass的继承有完全的控制，尽管它们之间有一个帮助类。

这确实意味着您希望拥有super的每个类都必须使用PrimaryParent助手类，并且每个子类只能从一个使用PrimaryParent的类继承(因此得名)。

这个方法的另一个限制是，MyObject只能继承一个从PrimaryParent继承的类，而且这个类必须使用PrimaryParent继承。我的意思是:

class SomeOtherBase : public PrimaryParent<Ancestor>{}

class MixinClass {}

//Good
class BaseClass : public PrimaryParent<SomeOtherBase>, public MixinClass
{}


//Not Good (now 'super' is ambiguous)
class MyObject : public PrimaryParent<BaseClass>, public SomeOtherBase{}

//Also Not Good ('super' is again ambiguous)
class MyObject : public PrimaryParent<BaseClass>, public PrimaryParent<SomeOtherBase>{}

在你放弃这个选择之前，因为似乎有很多限制，而且每一项继承之间都有一个中间阶层，这些东西并不坏。

多重继承是一个强大的工具，但在大多数情况下，只会有一个主父类，如果有其他父类，它们可能是Mixin类，或者无论如何都不从PrimaryParent继承的类。如果仍然需要多重继承(尽管在许多情况下使用组合来定义对象而不是继承会更有利)，则不要在该类中显式地定义super，而不从PrimaryParent继承。

必须在每个类中定义super的想法对我来说不是很有吸引力，使用PrimaryParent允许super，显然是一个基于继承的别名，留在类定义行中，而不是数据应该去的类主体中。

不过可能只有我是这样。

当然，每个情况都是不同的，但在决定使用哪个选项时，请考虑我所说的这些事情。

我经常用这个。就在我发现自己输入了几次基类类型时，我将用一个类似于您的类型定义替换它。

我认为这是一个很好的用途。如前所述，如果基类是模板，则可以节省输入。此外，模板类可以接受参数，作为模板应该如何工作的策略。只要基类的接口保持兼容，您就可以自由地更改基类类型，而不必修复对它的所有引用。

我认为通过typedef的使用已经足够了。无论如何，我不知道它将如何构建到语言中，因为多重继承意味着可以有许多基类，因此您可以根据逻辑上认为最重要的基类的类型定义它。

在父类中使用类型定义的另一个原因是在对象的继承中使用复杂的模板。

例如:

template <typename T, size_t C, typename U>
class A
{ ... };

template <typename T>
class B : public A<T,99,T>
{ ... };

在类B中，理想的情况是为a提供一个类型定义，否则你将在任何你想引用a成员的地方重复它。

在这些情况下，它也可以使用多重继承，但你不会有一个名为'super'的类型定义，它会被称为'base_A_t'或类似的东西。

——jeffk + +

我不会说太多，除了目前的代码注释，说明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向上调用，这在实际生活中并不是很有用，但它说明了两者的区别。