Solución:
Las plantillas ofrecen una ventaja cuando desea realizar la misma acción en tipos que pueden ser diferentes. Un simple ejemplo:
template <typename T>
T foo(const T& a, const T& b) { return a + b; }
Puede utilizar la sobrecarga cuando desee aplicar diferentes operaciones según el tipo:
struct Foo{ void foo() const {} };
void foo(int i) { std::cout << "i = " << i << "n"; }
void foo(const Foo& f) { f.foo(); }
Puede lograr lo anterior utilizando plantillas y especializaciones de plantillas, pero dichas especializaciones deberían representar algunas excepciones al caso general.
Las plantillas no pueden aceptar un número variable de argumentos. Las sobrecargas pueden. Además, una plantilla indica que puede operar con cualquier tipo de datos, pero no tiene sentido representar esto cuando, de hecho, la gran mayoría de las plantillas serían solo especializaciones (en su sistema). Además, las sobrecargas pueden ser virtual y las especializaciones de plantillas no pueden. Las especializaciones tampoco pueden diferir en sus firmas de las de base.
template<typename T> void foo(T& t);
template<> void foo<std::string>(std::string* ptr); // Illegal
void foo(std::string* ptr); // Legal
Esto limitaría gravemente los tipos de sobrecarga que podría producir en comparación con el sistema actual.
Por lo general, usa plantillas cuando desea realizar el mismo conjunto de operaciones en muchos tipos de datos diferentes.
Por lo general, usaría la sobrecarga de funciones cuando desee realizar diferentes operaciones en ciertos conjuntos de datos.
la ventaja de las plantillas en una situación en la que desea realizar el mismo conjunto de operaciones en muchos tipos de datos diferentes, es que el compilador manejará por usted en el momento de la compilación cualquier tipo nuevo posible que pueda crear en el futuro que use la función de plantilla. si usara la sobrecarga de funciones, tendría que crear una nueva sobrecarga de funciones cada vez que creara un nuevo tipo que quisiera pasar a la función específica.