即使模板类实现了抽象方法，C++ 中的类仍然是抽象的

Question

如果编译器认为模板类的实例仍然是抽象的，即使要派生的类实现了这个抽象方法，我想知道这是否符合标准。

我的编译器是 Microsoft C/C++ Compiler 18.00.40629 (Visual Studio 2013)

下面的课程：

class MyClass {
    virtual void Method() = 0;
};

template <typename T>
class MyClassT : public MyClass, public T {
};

class MyTemplateData {
    void Method() {
    }
};

MyClassT<MyTemplateData> MyInstance;

据我了解，MyClassT<MyTemplateData> 类是一个有效的实例，它实现了所有抽象方法，因为 MyClassT 派生自 MyClass 和 MyTemplateData。为了能够通过保持所需行为来编译此类，我应该进行哪些更改？

有一个解决方案，但让我解释一下为什么我不想关注：

template <typename T>
class MyClassT : public MyClass, public T {
    void Method() {
        T::Execute();
    }
};

在上述情况下，它确实会编译，但是这会假设我的T 类总是实现Method。但是我想要的是在MyClassT 中有一个空的Method，而不是如果T 类实现了它，则应该被T::Method 覆盖。

所以下面的代码也可以编译，但是T::Method 永远不会被调用。

template <typename T>
class MyClassT : public MyClass, public T {
    void Method() {
    }
};

MyClass* Interface = new MyClassT<MyTemplateData>();
Interface->Method(); // <- here, MyTemplateData::Method() gets never called

是否有解决方案，或者这是编译器特定的错误？

编辑：再举一个例子，这次编译器应该确切地知道派生类实现了所需的抽象方法。

struct InterfaceA {
    virtual void MethodA() = 0;
};

struct InterfaceAB : InterfaceA {
    virtual void MethodB() = 0;
};

class ImplA : public virtual InterfaceA {
public:
    void MethodA() {
    }
};

class ImplAB : public virtual InterfaceAB, public ImplA {
    void MethodB() {
    }
};

编译器期望类ImplAB 实现MethodA，因为InterfaceAB 需要同时实现MethodA 和MethodB。然而，由于ImplAB 也是从ImplA 派生的，并且编译器确切地知道ImplA 实现了该接口，所以应该没有问题。

至少应该有一个关键字来提示编译器在哪里实现抽象方法，如下例所示。我看不出有任何理由至少在以任何方式使用 VTABLE 时应该避免这种情况。

class ImplABCD : public implements InterfaceABCD, public ImplA, public ImplB, public ImplC, public ImplC {
};

此implements 关键字表示来自InterfaceABCD 的所有抽象方法都将在ImplABCD 中实现或已经在其中一个继承类中实现。如果存在签名歧义，则在从具有相同基类的多个类继承时，按照 c++ 规范已经完成的处理情况。

Answer 1

如果您不想使用@ForEveR 解决方案，那么您可以执行以下操作。

使用 SFINAE std::enable_if。 类似于：

template <typename T>
struct MyClassT : public MyClass, public T
{
    typename std::enable_if<has_func_method<T>::value, void>::type Method()
    {
        T::Method();
    }

    typename std::enable_if<!has_func_method<T>::value, void>::type Method()
    {
        //do nothing
    }
};

编辑： 您可以在类本身而不是在内部使用 SFINAE。 那样可能会更好。 这是一个工作示例：

// Example program
#include <iostream>
#include <string>

struct MyClass
{
    virtual void Method() = 0;
};

template< typename C, typename = void >
struct has_func_method
  : std::false_type
{};

template< typename C>
struct has_func_method< C, typename std::enable_if<
    std::is_same<
        decltype( std::declval<C>().Method()),
        void
    >::value
>::type >
  : std::true_type
{};

template <typename T, bool has_method = has_func_method<T>::value>
struct MyClassT : public MyClass, public T
{
};

template <typename T>
struct MyClassT<T, false> : public MyClass, public T
{
    void Method()
    {
        //do nothing
        std::cout << "doing nothing" << std::endl;
    }
};

template <typename T>
struct MyClassT<T, true> : public MyClass, public T
{
    void Method()
    {
        std::cout << "calling T::Method" << std::endl;
        T::Method();
    }
};

struct DataWithoutMethod
{
};

struct DataWithMethod
{
    void Method()
    {
        std::cout << "method called" << std::endl;
    }
};


int main()
{
    MyClassT<DataWithoutMethod> data;
    data.Method();
    MyClassT<DataWithMethod> data2;
    data2.Method();
}

Answer 2

我想知道这是否符合标准的行为

是的。

如果编译器认为模板类的实例仍然是抽象的

是的。

即使派生的类实现了这个抽象方法。

没有。

你没有覆盖MyClass::Method； T::Method 无关。

让我们暂时摆脱模板，因为它们无关紧要并且会分散问题的注意力：

class MyClass {
    virtual void Method() = 0;
};

class MyTemplateData {
    void Method() {
    }
};

class MyClassT : public MyClass, public MyTemplateData {
};

继承树如下：

MyClass  MyTemplateData
    \       /
     \     /
    MyClassT

Method 必须在左侧实现；也就是说，在MyClass、MyClassT、或介于两者之间。右边是一个不相关的继承分支：当你创建MyTemplateData::Method时，它并没有覆盖MyClass::Method，因为MyTemplateData和MyClass之间没有继承关系。

覆盖仅适用于直线。