Especialización de plantilla VS Función de sobrecarga

Question

Un libro de texto Tengo notas de que puede proporcionar su propia implementación para funciones de biblioteca estándar como swap(x,y) a través de la especialización de plantillas para la sobrecarga de funciones. Esto sería útil para cualquier tipo que se pueda beneficiar de algo más que un intercambio de tareas, como STL containers por ejemplo (que ya tienen swaps escritos, lo sé).

Mis preguntas son:

1. ¿Qué es mejor: la especialización de plantilla para darle a su aplicación especializada de intercambio o sobrecarga de funciones que proporciona los parámetros exactos que desea utilizar sin una plantilla?

2. ¿Por qué es mejor? O si son iguales, ¿por qué es esto?

Answer 1

Cuento corto: sobrecarga cuando puedas, especialízate cuando lo necesites.

Relato largo: C++ trata la especialización y las sobrecargas de manera muy diferente. Esto se explica mejor con un ejemplo.

template <typename T> void foo(T); 
template <typename T> void foo(T*); // overload of foo(T) 
template <>   void foo<int>(int*); // specialisation of foo(T*) 

foo(new int); // calls foo<int>(int*); 

Ahora intercambiemos los dos últimos.

template <typename T> void foo(T); 
template <>   void foo<int*>(int*); // specialisation of foo(T) 
template <typename T> void foo(T*); // overload of foo(T) 

foo(new int); // calls foo(T*) !!! 

El compilador tiene una resolución de sobrecarga incluso antes de ver las especializaciones. Entonces, en ambos casos, la resolución de sobrecarga elige foo(T*). Sin embargo, solo en el primer caso encuentra foo<int*>(int*) porque en el segundo caso la especialización int* es una especialización de foo(T), no de foo(T*).

---

Usted mencionó std::swap. Esto hace las cosas aún más complicadas.

La norma dice que puede agregar especializaciones al espacio de nombre std. Genial, entonces tiene algún tipo de Foo y tiene un intercambio de rendimiento, entonces solo se especializa en swap(Foo&, Foo&) en el espacio de nombres std. No hay problemas.

¿Pero y si Foo es una clase de plantilla? C++ no tiene especialización parcial de funciones, por lo que no puede especializar swap. Su única opción es sobrecargar, pero el estándar dice que no tiene permitido agregar sobrecargas en el espacio de nombres std.

usted tiene dos opciones en este punto:

1. crear una función swap(Foo<T>&, Foo<T>&) en su propio espacio de nombres, y esperamos que se encuentra a través de la ADL. Digo "esperanza" porque si la biblioteca estándar llama a swap como std::swap(a, b); entonces ADL simplemente no funcionará.

2. Ignore la parte del estándar que dice no agregar sobrecargas y hágalo de todos modos. Honestamente, a pesar de que técnicamente no está permitido, en todos los escenarios realistas va a funcionar.

Una cosa para recordar es que no hay garantía de que la biblioteca estándar utiliza swap en absoluto. La mayoría de los algoritmos usan std::iter_swap y en algunas implementaciones que he visto, no siempre se envían a std::swap.

Answer 2

No tiene permiso para sobrecargar las funciones en el espacio de nombres std, pero puede autorizar las plantillas (como recuerdo), de modo que esa es una opción.

La otra opción es poner su función swap en el mismo espacio de nombres en el que está operando y using std::swap; antes de llamar a un intercambio no calificado.

Answer 3

Hay poco que añadir a la respuesta de Peter Alexander. Permítanme mencionar un uso en el que la especialización de funciones podría ser preferible a la sobrecarga: si tiene que seleccionar entre las funciones sin los parámetros.

E.g.

template<class T> T zero(); 
template<> int zero() { return 0; } 
template<> long zero() { return 0L; } 

hacer algo similar con la sobrecarga de funciones, habría que añadir un parámetro a la función de firma:

int zero(int) { return 0; } 
long zero(long) { return 0L; }