Est-ce que la spécialisation d'un modèle de fonction est virtuelle?

Question

En C++, une spécialisation de modèle de fonction est supposée agir exactement comme une fonction normale. Cela signifie-t-il que je peux en faire un virtuel?

Par exemple:

struct A 
{ 
    template <class T> void f(); 
    template <> virtual void f<int>() {} 
}; 

struct B : A 
{ 
    template <class T> void f(); 
    template <> virtual void f<int>() {} 
}; 

int main(int argc, char* argv[]) 
{ 
    B b; 
    A& a = b; 
    a.f<int>(); 
} 

Visual Studio 2005 me donne l'erreur suivante:

fatal error C1001: An internal error has occurred in the compiler.

Answer 1

Belle erreur de compilation. Pour ce type de vérifications, je me replie toujours sur le compilateur Comeau avant de revenir à la norme et de vérifier.

Comeau C/C++ 4.3.10.1 (Oct 6 2008 11:28:09) for ONLINE_EVALUATION_BETA2 Copyright 1988-2008 Comeau Computing. All rights reserved. MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 3: error: "virtual" is not allowed in a function template declaration template virtual void f(); ^

"ComeauTest.c", line 10: error: "virtual" is not allowed in a function template declaration template virtual void f(); ^

Maintenant, comme il a été posté par un autre utilisateur, le fait est que la norme ne vous permet pas de définir des méthodes virtuelles templated. La logique est que pour toutes les méthodes virtuelles, une entrée doit être réservée dans le vtable. Le problème est que les méthodes de modèle ne seront définies que lorsqu'elles auront été instanciées (utilisées). Cela signifie que le vtable finirait par avoir un nombre différent d'éléments dans chaque unité de compilation, en fonction du nombre d'appels différents à f() avec différents types se produisent. Puis l'enfer serait soulevée ...

Si ce que vous voulez est une fonction sur l'un basé sur un modèle ses arguments et une version spécifique étant virtuelle (note de la part de l'argument), vous pouvez le faire:

class Base 
{ 
public: 
    template <typename T> void f(T a) {} 
    virtual void f(int a) { std::cout << "base" << std::endl; } 
}; 
class Derived : public Base 
{ 
public: 
    virtual void f(int a) { std::cout << "derived" << std::endl; } 
}; 
int main() 
{ 
    Derived d; 
    Base& b = d; 
    b.f(5); // The compiler will prefer the non-templated method and print "derived" 
} 

Si vous voulez généraliser cela pour n'importe quel type, alors vous n'avez pas de chance. Considérons un autre type de délégation à la place du polymorphisme (l'agrégation + délégation pourrait être une solution). Plus d'informations sur le problème à portée de main aideraient à déterminer une solution.

Answer 2

Selon http://www.kuzbass.ru:8086/docs/isocpp/template.html ISO/CEI 14882: 1998:

-3- A member function template shall not be virtual.

Exemple:

template <class T> struct AA { 
    template <class C> virtual void g(C); // Error 
    virtual void f();      // OK 
}; 

Answer 3

Comme d'autres l'ont noté, ce code n'est pas légal car un modèle de fonction membre ne peut pas être déclaré virtual.

Pourtant, même Visual Studio 2012 selfs sur ce point: Click here for full size

journaux d'événements indiquent que le compilateur est écrasé sur 0xC0000005 ou STATUS_ACCESS_VIOLATION. C'est marrant comment une certaine construction de code (illégale) peut rendre le segfault du compilateur ...