如何在 C++ 模板子类中部分重载虚函数？

Question

我正在尝试创建一个非模板基类来创建一个接口，通过该接口我可以与派生的模板类进行交互。我希望使用部分虚函数重载，但有些东西不起作用，我不知道为什么。 谁能解释为什么我下面的代码返回：

B match = False
D match = True
E match = False

而不是 B、D 返回 True 和 E 返回 False？我原以为派生类中的重载运算符会获取指向 int '&i' 的指针并被调用，但事实并非如此。

需要明确的是，我不是要 - 覆盖 - 匹配的基本版本，我是要 - 重载 - 它，特别是希望它有一个不同的，在这种情况下更专业的接口，而不是Base，在使用其函数签名时接管。

我还试图避免必须为我可能实例化的派生模板的每种风格扩展基类。

更陌生，我 - 可能 - 只是在这里发疯，但我发誓这在不久前的某个时候对我有用！ Fwiw 我在 OSX 10.5 上，使用 llvm 7.0.0 和 clang 700.1.76。这可能是编译器的特性吗？

虽然我在这里尝试（未成功）使用部分重载，但我真的很愿意接受任何方法来解决通过其参数类型选择模板实例函数的问题，而不增加类，if-thens/case或向基类添加特定的专业化。如果您有其他类似功能的方法，我很乐意听到。

感谢您提供的任何见解！

#include <stdio.h>

class Base
{
public:
  Base() {}
  virtual ~Base(){}

  virtual bool match( const void *data ) const { return false; }
};

template <class Type>
class Derived: public Base
{
public:
  Derived():Base() {}
  ~Derived() override{}

  virtual bool match( const Type *data ) const { return true; }
};

int main(int argc, char **argv)
{
  Derived<int>   *d = new Derived<int>();
  Derived<float> *e = new Derived<float>();
  Base *b           = d;

  int i;
  printf("B match = %s\n",b->match(&i)?"True":"False");
  printf("D match = %s\n",d->match(&i)?"True":"False");
  printf("E match = %s\n",e->match(&i)?"True":"False");

}

Answer 1

如果您要手动创建 Derived<int> 作为一个类，它的成员函数将是：

virtual bool match( const int *data ) const { return true; }

它不会覆盖基类。因此，当你用基类指针调用函数时，它执行基类实现，当你用派生类指针调用它时，它执行派生类实现。

如果您使用 override 关键字，您将能够在编译时发现问题。

template <class Type>
class Derived: public Base
{
public:
  Derived():Base() {}
  ~Derived() override{}

  virtual bool match( const Type *data ) const override { return true; }
};

您应该会看到与该更改相关的编译时错误。

在http://ideone.com/8rBQ6B查看编译器错误。

更新，以回应 OP 的评论

如果您不想覆盖：

1. 不要在成员函数声明中使用virtual。

2. 通过使用将基类函数带入派生类的作用域

   using Base::match
   

   这是怎么做的：

   template <class Type>
   class Derived: public Base
   {
   public:
     Derived():Base() {}
     ~Derived() override{}
   
     using Base::match;
     bool match( const Type *data ) const { return true; }
   };
   

Answer 2

这里的问题是Derived::match 不匹配Base::match。虚函数的函数签名必须相同才能使机制起作用。因此，使用您的代码 Derived::match 重载而不是覆盖它。

如果我们改变

virtual bool match( const Type *data ) const { return true; }

到

virtual bool match( const void *data ) const { return true; }

然后我们得到

B match = True
D match = True

Live Example

Answer 3

因为函数的签名不匹配：

在class Base 你有

virtual bool match( const void *data ) const { return false; }

注意const void * 参数类型

然后在Derived 你有

virtual bool match( const Type *data ) const { return true; }

这里的Type 是int（来自main 的Derived<int> *d）

只需在 Base 中添加一个带有 const int* data 签名的虚拟，就可以开始了。

是的，这确实意味着在Base 中，您必须为您希望与Derived 一起使用的每个Type 添加match 的重载。

Answer 4

这不起作用的原因是派生类实际上并没有覆盖基类中的虚函数。为了覆盖基类中的虚函数，派生类必须具有完全相同相同的签名（请参阅下面的注释了解例外情况）。在这种情况下，签名是不同的，因为基类中的虚函数采用void *，而派生类中的函数采用type *。

让我们做一个小改动，将override 指令添加到派生类的函数签名中：

#include <stdio.h>

class Base
{
public:
  Base() {}
  virtual ~Base(){}

  virtual bool match( const void *data ) const { return false; }
};

template <class Type>
class Derived: public Base
{
public:
  Derived():Base() {}
  ~Derived() override{}

  virtual bool match( const Type *data ) const override { return true; }
};

int main(int argc, char **argv)
{
  Derived<int> *d = new Derived<int>();
  Base *b         = d;

  int i;
  printf("B match = %s\n",b->match(&i)?"True":"False");
  printf("D match = %s\n",d->match(&i)?"True":"False");

}

当我们现在编译时会发生以下情况：

main.cpp: In instantiation of 'class Derived<int>':
main.cpp:24:38:   required from here
main.cpp:19:16: error: 'bool Derived<Type>::match(const Type*) const [with Type = int]' marked 'override', but does not override
   virtual bool match( const Type *data ) const override { return true; }

假设我们使用的是 C++11，最好使用override 来确保我们确实覆盖了基类虚函数。

上面的注意事项：有一种叫做 covariant return type 的东西，其中覆盖不必具有相同的签名，但这超出了问题的范围。

Answer 5

感谢 o_weisman 在原始问题下的评论，我能够使用函数模板找到可行的解决方案（见下文）。诚然，在我的解决方案的当前形式中，我利用了 Derived 的每个类型实例都是单例的限制。这适用于我的特定设计，但可以根据需要扩展行为。允许 Derived 的多个实例的一种可能性可能是检查 Base::match 中的“this”指针是否在所有实例的集合中（在构造/销毁时更新的静态集合变量中跟踪），而不是反对一个单例实例。无论如何，我希望这对可能面临类似设计挑战的人有所帮助。

#include <stdio.h>
#include <assert.h>

template <class Type> class Derived;
class Base
{
public:
  Base() {}
  virtual ~Base(){}

  template <class Type>
  bool match( const Type *data ) const { return (Derived<Type>::instance() == this); }

};

template <class Type>
class Derived: public Base
{
public:
  Derived(): Base() { assert(!ourInstance); ourInstance = this; }
  ~Derived() override{}

  static const Base *instance() { return ourInstance; }

protected:
  static const Derived<Type> *ourInstance;

};

template <class Type>
const Derived<Type> *Derived<Type>::ourInstance = NULL;

int main(int argc, char **argv)
{
  Derived<int>   *d = new Derived<int>();
  Derived<float> *e = new Derived<float>();
  Base *b           = d;

  int i;
  printf("B match = %s\n",b->match(&i)?"True":"False");
  printf("D match = %s\n",d->match(&i)?"True":"False");
  printf("E match = %s\n",e->match(&i)?"True":"False");

}

这会产生以下结果：

B match = True
D match = True
E match = False