Función

Question

¿Cuál es la razón de las segundas ménsulas <> en la plantilla de función siguiente:

template<> void doh::operator()<>(int i) 

Esto ocurrió en SO question donde se sugirió que hay entre paréntesis que faltan después de operator(), sin embargo pude no encuentras la explicación

entiendo el significado si se tratara de una especialización tipo (completa especialización) de la forma:

template< typename A > struct AA {}; 
template<> struct AA<int> {};   // hope this is correct, specialize for int 

Sin embargo para las plantillas de función:

template< typename A > void f(A); 
template< typename A > void f(A*); // overload of the above for pointers 
template<> void f<int>(int);   // full specialization for int 

Dónde encaja esto en este scenarion ?:

template<> void doh::operator()<>(bool b) {} 

Código de ejemplo que parece funcionar y no da ningún wa rnings/error (gcc 3.3.3 usado):

#include <iostream> 
using namespace std; 

struct doh 
{ 
    void operator()(bool b) 
    { 
     cout << "operator()(bool b)" << endl; 
    } 

    template< typename T > void operator()(T t) 
    { 
     cout << "template <typename T> void operator()(T t)" << endl; 
    } 
}; 
// note can't specialize inline, have to declare outside of the class body 
template<> void doh::operator()(int i) 
{ 
    cout << "template <> void operator()(int i)" << endl; 
} 
template<> void doh::operator()(bool b) 
{ 
    cout << "template <> void operator()(bool b)" << endl; 
} 

int main() 
{ 
    doh d; 
    int i; 
    bool b; 
    d(b); 
    d(i); 
} 

Salida:

operator()(bool b) 
template <> void operator()(int i) 

Answer 1

He mirado hacia arriba, y encontró que se especifica mediante 14.5.2/2:

A local class shall not have member templates. Access control rules (clause 11) apply to member template names. A destructor shall not be a member template. A normal (non-template) member function with a given name and type and a member function template of the same name, which could be used to generate a specialization of the same type, can both be declared in a class. When both exist, a use of that name and type refers to the non-template member unless an explicit template argument list is supplied.

Y proporciona un ejemplo:

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

template <> void A<int>::f(int) { } // non-template member 
template <> template <> void A<int>::f<>(int) { } // template member 

int main() 
{ 
    A<char> ac; 
    ac.f(1); //non-template 
    ac.f(’c’); //template 
    ac.f<>(1); //template 
} 

Nótese que en S Los términos estándar, specialization se refieren a la función que se escribe utilizando una especialización explícita y a la función generada mediante instanciación, en cuyo caso tenemos que ver con una especialización generada. specialization no solo se refiere a las funciones que crea usando explícitamente la especialización de una plantilla, para la cual a menudo solo se usa.

Conclusión: GCC se equivoca. Comeau, con la que yo también probé el código, lo hace bien y emite un diagnóstico:

"ComeauTest.c" , line 16: error: "void doh::operator()(bool)" is not an entity that can be explicitly specialized template<> void doh::operator()(bool i)

en cuenta que no se queja de la especialización de la plantilla para int (sólo para bool), ya que doesn' t se refieren al mismo nombre y tipo: El tipo de función que la especialización tendría es void(int), que es distinto del tipo de función de la función miembro no plantilla, que es void(bool).