C++: ¿Cómo evitar que la plantilla especialice un puntero?

Question

Comienzo a disculparme si soy tan estúpido como para no encontrar la respuesta si es tan obvio.

He visto docenas de páginas que hablan de tener una especialización de plantilla específica para los parámetros del puntero.

Me gustaría poder evitar que una plantilla especialice los parámetros del puntero, pero no puedo encontrar la manera de hacerlo.

template< class T > 
void function(T arg) 
{ 
    //... 
} 

int main() 
{ 
    int i = 42; 

    function(i); // Ok 
    function(&i); // Die bastart with a compiler error! 
} 

¿Es posible?

Gracias.

Answer 1

Se puede declarar la especialización (en este caso es técnicamente sólo una sobrecarga) pero no definirlo :)

template<typename T > 
void function(T arg) 
{ 
//... 
} 

template<typename T > 
void function(T* arg); //no definition 

int main() 
{ 
    int i = 42; 
    function(i); // Ok 
    function(&i); //ERROR 
} 

Answer 2

soy yo un novato plantilla metaprogramming, pero creo

template<typename T> 
void function(typename std::enable_if<!std::is_pointer<T>::value,T>::type arg) 
{ 
    //... 
} 

debería funcionar, ya que esta función solo debería existir para parámetros que no sean de puntero. Por supuesto, esto requiere C++ 11 o al menos TR1 o características de rasgos de tipo boost.

Answer 3

En C++ 11, puede utilizar static_assert de una manera como esto:

template<class T> 
void func(T arg) { 
    static_assert(!std::is_pointer<T>::value, 
       "The argument to func must not be a pointer."); 
    // Do something after the static_assert. 
    // Now you are sure that T isn't a pointer. 
} 

Un ejemplo se puede encontrar here on Ideone.

Lo recomiendo porque dará más mensajes de error útiles cuando alguien intente llamar a su función con un puntero (los errores del enlazador pueden ser muy confusos en este caso). Además, los errores del vinculador no se mostrarán antes de que se produzca la vinculación.