// renvoie le plus grand entre A et B
template<typename T>
const T & Max( const T & A, const T & B )
{
    return A > B ? A : B;
}

const int & Max( const int & A, const int & B )
{
    return A > B ? A : B;
}

const float & Max( const float & A, const float & B )
{
    return A > B ? A : B;
}

#include <iostream>
#include <sstream>

class StringBuilder
{
public:
    template<typename T>
    void Append( const T & t )
    {
        this->oss << t;
    }

    std::string GetString() const
    {
        return this->oss.str();
    }

private:
    std::ostringstream oss;
};

int main()
{
    StringBuilder sb;
    sb.Append( 10 );
    sb.Append( '\t' );
    sb.Append( "coucou " );
    sb.Append( 54.12 );
    std::cout << sb.GetString() << '\n';
}

int Max( int A, int B )
{
    return ( A >= B ) ? ( A ) : ( B );
}

template<typename T>
T Max( T A, T B )
{
    return ( A >= B ) ? ( A ) : ( B );
}

Max<int>( 1, 2 );

class Test
{
};

Test a;
Test b;

Max<Test>( a, b );

#include <iostream> 

template <typename T> 
class Exemple 
{ 
public : 

    Exemple(const T& Val = T()); 

    template <typename U> 
    Exemple(const Exemple<U>& Copy); 

    const T& Get() const; 

    template <typename T2> 
    friend std::ostream& operator <<(std::ostream& Stream, const Exemple<T2>& Ex); 

private : 

    T Value; 
}; 

template <typename T> 
Exemple<T>::Exemple(const T& Val) : 
Value(Val) 
{ 

} 

template <typename T> 
template <typename U> 
Exemple<T>::Exemple(const Exemple<U>& Copy) : 
Value(static_cast<T>(Copy.Get())) 
{ 
    // Attention, ceci n'est pas le constructeur par copie ! 
} 

template <typename T> 
const T& Exemple<T>::Get() const 
{ 
    return Value; 
} 

template <typename T> 
std::ostream& operator <<(std::ostream& Stream, const Exemple<T>& Ex) 
{ 
    return Stream << Ex.Value; 
} 

int main() 
{ 
    Exemple<int> A(3); 
    Exemple<float> B(A); 

    std::cout << A << std::endl; 
    std::cout << B << std::endl; 

    return 0; 
}

// Version générique 
template <typename T>
void QuiSuisJe( const T & x ) 
{ 
    std::cout << "Je ne sais pas" << std::endl; 
} 

// Spécialisation pour les int 
template <>
void QuiSuisJe<int>( const int & x ) 
{ 
    std::cout << "Je suis un int" << std::endl; 
} 

// Spécialisation pour ma classe 
template <>
void QuiSuisJe<MaClasse>( const MaClasse & x ) 
{ 
    std::cout << "Je suis un MaClasse" << std::endl; 
} 

// Test 
MaClasse Test1; 
int Test2; 
float Test3; 

QuiSuisJe( Test1 ); // "Je suis un MaClasse" 
QuiSuisJe( Test2 ); // "Je suis un int" 
QuiSuisJe( Test3 ); // "Je ne sais pas"

template<typename T>
struct Modele 
{ 
    void QuiSuisJe() 
    { 
        std::cout << "Je suis un Modele<inconnu>" << std::endl; 
    } 
}; 

template<>
struct Modele<int> 
{ 
    void QuiSuisJe() 
    { 
        std::cout << "Je suis un Modele<int>" << std::endl; 
    } 

    void CestQuoiCetteFonction() 
    { 
        // On peut tout à fait ajouter des fonctions
        // en fait le contenu de la classe peut être totalement différent ! 
    } 
}; 

Modele<float> M1; 
Modele<int> M2; 

M1.QuiSuisJe(); // "Je suis un Modele<inconnu>" 
M2.QuiSuisJe(); // "Je suis un Modele<int>" 

M1.CestQuoiCetteFonction(); // Erreur : 'fonction inconnnue' 
M2.CestQuoiCetteFonction(); // OK

template <typename T>
void Fonction( T x ) 
{ 
} 

Fonction<double>(5.2f); 
// Equivalent à 
Fonction( 5.2 );

template <typename T>
T Fonction()
{
    return T(); // renvoie le type 
} 

int x = Fonction(); // Erreur : 'impossible de déduire l'argument de modèle' 
int x = Fonction<int>(); // OK

template <typename T>
void Fonction( T x1, T x2 ) 
{ 
} 

int x1 = 5; // premier argument de type int
double x2 = 6.5; // second argument de type double

Fonction( x1, x2 ); // Erreur : 'paramètre ambigu' 
Fonction<double>( x1, x2 ); // OK
Fonction( static_cast<double>( x1 ), x2 ); // OK

// le .h 
#ifndef MON_TEMPLATE_H 
#define MON_TEMPLATE_H 

template <class T> 
class Liste { ... }; 

#include "mon_template.cpp" 
#endif
 
// le .cpp
#ifdef MON_TEMPLATE_H // évite les erreurs de compilation ;-) 

template <class T> 
Liste<T>::Liste () { ... } 

#endif

#include <list> 

template <typename T> // à priori, on ne sait rien du type T
class MaClasse 
{ 
public:
    typedef std::list<T>::iterator Iter; // Erreur avec certains compilateurs (ou warning, ou rien)
    typedef typename std::list<T>::iterator Iter2; // Ok 
};

#include <vector>

typedef std::vector Tableau; // erreur de compilation

Tableau<int> t;

#include <vector>

template <typename T>
struct Tableau
{
    typedef std::vector<T> type;
};

Tableau<int>::type t;