Why template?

template<typename T>void Foo(const T& A){    return T(A);}int main(){    Foo<int>(6);    Foo<float>(6.0F);    return 0;}

void FooInt(const int& A){    return int(A);}void FooFloat(const float& A){    return float(A);}int main(){    FooInt(6);    FooFloat(6.0F);    return 0;}

#include <iostream>// an interface for some useless objectclass interface {public:      virtual void foobar() const = 0;};// a few implementations of said interfaceclass implementation_a : public interface {public:      void foobar() const { std::cout << "implementation a\n"; };};class implementation_b : public interface {public:      void foobar() const { std::cout << "implementation b\n"; };};// function that uses common interface (note the virtual function call)void use_dynamic_polymorphism( interface * const pb ) { pb->foobar(); }// function template that uses implementations directly (no virtual function call)template< typename implementation >void use_static_polymorphism( implementation & impl ) { impl.foobar(); }int main() {   // here we use base pointers and virtual function calls for dynamic polymorphism, or   // polymorphism that occurs at run-time   interface * pinterface = new implementation_a;   use_dynamic_polymorphism( pinterface );   delete pinterface;   pinterface = new implementation_b;   use_dynamic_polymorphism( pinterface );   delete pinterface;   // here we use concrete objects and a function template for static polymorphism, or   // polymorphism that occurs at compile-time.   implementation_a i_a;   implementation_b i_b;   // this saves us a function call, new/delete pairs, and is type-safe   use_static_polymorphism( i_a );   use_static_polymorphism( i_b );   return 0;}