// 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

// exemple.h

#ifndef EXEMPLE_H
#define EXEMPLE_H

template <typename T>
class Exemple
{
public:
    Exemple();
};

#include "exemple.tpp" // <-- astuce ici !!!
#endif

// exemple.tpp

template <typename T>
Exemple<T>::Exemple()
{
}

template <typename T>
class MaClasse
{
    ...
};

template <typename T>
class MaClasse
{
public :
    typedef int MonType;
};

template <typename T>
void MaFonction(T x)
{
    MaClasse<T>::MonType t;
	...
}

template <>
class MaClasse<int>
{
public :
    static const int MonType = 5;
};

template <typename T>
void MaFonction(T x)
{
    MaClasse<T>::MonType t; // Que se passe-t-il ici si T est int ??
    ...
}

template <typename T>
void MaFonction(T x)
{
    typename MaClasse<T>::MonType t;
    ...
}

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;

template <typename T> struct ValeurNulle;

typename <> struct ValeurNulle<int>         {static int Zero()         {return 0;}};
typename <> struct ValeurNulle<std::string> {static std::string Zero() {return "";}};
typename <> struct ValeurNulle<MaClasse>    {static MaClasse Zero()    {return MaClasse(-1);}};
// ...

template <typename T>
void Fonction(T Valeur)
{
    T Ret = ValeurNulle<T>::Zero();
    // ...
}

"Les classes de politique ont beaucoup en commun avec les traits, mais en diffèrent du fait
qu'elles mettent moins l'accent sur les types et plus sur les comportements".

Andrei Alexandrescu, Modern C++ Design

template <typename T>
T Accumulation(const T* Debut, const T* Fin)
{
    T Resultat = 0;
    for ( ; Debut != Fin; ++Debut)
        Resultat += *Debut;

    return Resultat;
}

template <typename T>
struct Addition
{
    static void Accumuler(T& Resultat, const T& Valeur)
    {
        Resultat += Valeur;
    }
};

template <typename T, typename Operation>
T Accumulation(const T* Debut, const T* Fin)
{
    T Resultat = 0;
    for ( ; Debut < Fin; ++Debut)
        Operation::Accumuler(Resultat, *Debut);

    return Resultat;
}

template <typename T, typename Operation = Addition<T> >
struct Accumulation
{
    static T Accumule(const T* Debut, const T* Fin)
    {
        T Resultat = 0;
        for ( ; Debut < Fin; ++Debut)
            Operation::Accumuler(Resultat, *Debut);

        return Resultat;
    }
};

template <typename T>
T Accumule(const T* Debut, const T* Fin)
{
    return Accumulation<T>::Accumule(Debut, Fin);
}

template <typename T, typename Operation>
T Accumule(const T* Debut, const T* Fin)
{
    return Accumulation<T, Operation>::Accumule(Debut, Fin);
}

template <typename T, typename Operation = Addition<T> >
struct Accumulation
{
    static T Accumule(const T* Debut, const T* Fin)
    {
        T Resultat = ValeurNulle<T>::Zero();
        for ( ; Debut < Fin; ++Debut)
            Operation::Accumuler(Resultat, *Debut);

        return Resultat;
    }
};