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

Question

我试图创建一个非模板基类来创建一个接口，通过它我可以与派生模板类进行交互。我的希望是使用部分虚拟函数重载，但有些不起作用，我不知道为什么。 任何人都可以解释为什么我下面的代码返回：

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

，而不是B，d返回true，和E返回false？我本以为在派生类中的重载操作符会拿起指针到int'&我'并被调用，但它不。

为了清楚起见，我没有试图覆盖基本版本的匹配，我正在尝试对它进行过载，特别是希望它有一个不同的接口，在这种情况下，接口要比专用接口更多在Base中，它在使用其功能签名时接管。

我也试图避免为每个可能实例化的派生模板扩展基类。

即使是陌生人，我也可能会在这里疯狂，但我发誓这在不久前的某个时间对我有用！ Fwiw我在OSX 10.5上，使用llvm 7.0.0和clang 700.1.76。这可能是一个编译器特质？

虽然我试图（不成功）在这里使用部分重载，但我真的很开放，可以解决按照其参数类型选择模板实例函数的问题，而不会增加类，如果-thens /或者向基类添加特定的特化。如果您有另一种方法可以用于类似功能，我很乐意听到它。

谢谢您提供的任何见解！

#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

由于原来的问题下o_weisman的评论，我可以用函数模板找到一个有效的解决方案，（见下文）。无可否认，在我的解决方案的当前表单中，我利用了一个限制条件，即每个Derived的Type-in​​stance都是单例。这适用于我的特定设计，但行为可以根据需要进行扩展。一种可能允许派生多个实例的可能性可能是检查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 

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

如果你手动创建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 4

因为函数的签名不匹配：

在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）

只需添加一个虚拟的基础与const int* data签名，那么你会很好去。

是的，这确实意味着，在Base你必须添加的match过载，每Type你期望与Derived使用。

Answer 5

这是行不通的原因是因为派生类实际上并不是覆盖基类中的虚函数。为了覆盖基类中的虚函数，派生类必须有正好相同的签名（请参阅下面有关例外的说明）。在这种情况下，签名是不同的，因为基类中的虚函数采用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的地方，覆盖不必具有相同的签名，但这超出了问题的范围。