如果调用未覆盖的虚拟方法，如何强制编译器错误？

Question

在用 C++ 编写模板基类时，这是一个关于样式和安全性的相当普遍的问题。不过，请耐心等待，最后有一个具体问题......

我有一个模板基类，当类型 T 是原始类型（int、float 等）时，它完全实现了所需的功能。但是，如果 T 不是原始的（例如，如果 T 是一个需要使用一组特定参数调用构造函数的类），则需要重写某些方法，因此它们在模板。模板还包含一个纯虚方法，它强制它是抽象的，因此为了使用它必须从以下位置派生：基于原始类型的派生类可以使用提供的所有方法，并且只覆盖纯虚拟方法，而基于非原始类型的派生类应该覆盖所有虚拟方法。

例如：

template <typename T> class myTemplate
{
public:
    // Constructor:
    myTemplate<T>();

    // Destructor:
    virtual ~myTemplate();

    // General function, valid for all classes derived from this:
    void printMe()
    {
        printf("Hello, I'm from the template\r\n");
    }

    // Primitive function, must be overridden for non-primitive types:
    virtual T DoSomething(const T& myClass)
    {
        T result = result + static_cast<T>(1);
        return result;
    }

    // Primitive function, must be overridden for non-primitive types:
    virtual T DoSomethingElse(const T& myClass)
    {
        T result = result - static_cast<T>(1);
        return result;
    }

    // Pure Virtual function, must be overridden in all cases:
    virtual void RefrainFromDoingAnythingAtAll(const T& myClass) = 0
};


class myIntegerClass : public myTemplate<int>
{
public:
    virtual void RefrainFromDoingAnythingAtAll(const int& myInteger) {} 
};

假设现在我想创建一个派生类，我希望在其中调用“DoSomething”，但无法设想在任何情况下“DoSomethingElse”会有用。因此，我想重新实现“DoSomething”，但不打扰“DoSomethingElse”。然而，如果在某个时候派生类的“DoSomethingElse”方法确实被调用（或者是因为我真的想调用“DoSomething”但错误地写了错误的东西，或者因为出现了我遇到的情况之前没有想到），然后我想发出一个编译器警告来提醒我，除非我先重新实现 'DoSomethingElse'，否则我不能这样做。

例如：

class myWatermelonClass : public myTemplate<Watermelon>
{
public:
    virtual Watermelon DoSomething(const Watermelon &myWatermelon)
    {
          // Just return a copy of the original:
          Watermelon anotherWatermelon(myWatermelon);
          return anotherWatermelon;
    }

    virtual Watermelon DoSomethingElse(const Watermelon &myWatermelon)
    {
          // This routine shouldn't ever get called: if it does, then 
          // either I've made an error or, if I find that I really need
          // to reimplement it after all, then I'd better buckle down
          // and do it.
          < How do I make the compiler remind me of this? >
    }        

    virtual void RefrainFromDoingAnythingAtAll(const Watermelon& myWatermelon) {}   
};

显然我知道标准的#error 和#warning 编译器指令，但是如果我使用其中之一，那么每次编译时都会标记错误（或警告）。我想要的是确保在我疏忽调用时在编译时给出错误

DoSomethingElse(aSpecificWatermelon);

来自我代码中的某处，但不是其他情况。有没有办法做到这一点？或者这只是一个根本上糟糕的设计？

Answer 1

我认为您在滥用模板和虚拟调度组合。例如，您的基类不会为任何不支持加法运算符且可从 int 构造的类型进行编译。每次myTemplate 被隐式特化，所有虚函数将被编译，即使你在派生类中重写它们：

virtual T DoSomething(const T& myClass)
{
    T result = result + static_cast<T>(1); // compile error when T == Watermelon
    return result;
}

在您的情况下，您正在寻找的是显式模板专业化：

template <>
class myTemplate<Watermelon>
{
public:
    // General function, valid for all classes derived from this:
    void printMe()
    {
        printf("Hello, I'm from the Watermelon template specialisation\r\n");
    }

    virtual Watermelon DoSomething(const Watermelon &myWatermelon)
    {
        // Just return a copy of the original:
        Watermelon anotherWatermelon(myWatermelon);
        return anotherWatermelon;
    }

    // notice there's no DoSomethingElse!

    virtual void RefrainFromDoingAnythingAtAll(const Watermelon& myWatermelon) {}   
};

现在在 myTemplate<Watermelon> 的实例上调用 DoSomethingElse 会立即给您一个编译错误，因为没有这样的函数。

Answer 2

通过使用static_assert，当您尝试调用不符合特定条件的函数时，可能会导致编译错误。根本不需要虚函数。这是一个例子：

#include <iostream>
#include <type_traits>

using std::cout;

template <typename T>
struct myTemplate {
    void printMe() { cout << "Hello, I'm from the template\r\n"; }

    T DoSomething(const T& myClass)
    {
        static_assert(
          std::is_fundamental<T>::value,
          "DoSomething must be redefined in derived classes "
          "for non-fundamental types."
        );
        T result = myClass + static_cast<T>(1);
        return result;
    }

    T DoSomethingElse(const T& myClass)
    {
        static_assert(
          std::is_fundamental<T>::value,
          "DoSomethingElse must be redefined in derived classes "
          "for non-fundamental types."
        );
        T result = myClass - static_cast<T>(1);
        return result;
    }

    template <typename U>
    struct never_true { static const bool value = false; };

    void RefrainFromDoingAnythingAtAll(const T&)
    {
        static_assert(
            never_true<T>::value,
            "RefrainFromDoingAnythingAtAll must be redefined "
            "in derived classes."
        );
    }
};

struct Watermelon {
};

struct Lemon {
};

struct myIntegerClass : myTemplate<int> {
  void RefrainFromDoingAnythingAtAll(const int &) { }
};

struct myWatermelonClass : myTemplate<Watermelon> {
    Watermelon DoSomething(const Watermelon&)
    {
      return Watermelon();
    }

    Watermelon DoSomethingElse(const Watermelon&)
    {
      return Watermelon();
    }

    void RefrainFromDoingAnythingAtAll(const Watermelon &) { }
};


struct myLemonClass : myTemplate<Lemon> {
};

int main()
{
    myIntegerClass x;
    x.DoSomething(5); // works
    x.DoSomethingElse(5); // works
    x.RefrainFromDoingAnythingAtAll(5); // works
    myWatermelonClass y;
    y.DoSomething(Watermelon()); // works
    y.DoSomethingElse(Watermelon()); // works
    y.RefrainFromDoingAnythingAtAll(Watermelon()); // works
    myLemonClass z;
    z.DoSomething(Lemon()); // error
    z.DoSomethingElse(Lemon()); // error
    z.RefrainFromDoingAnythingAtAll(Lemon()); // error
}