FAQ C++Consultez toutes les FAQ

1
2
3
4
5
6
// 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; 
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#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'; 
}

1
2
3
4
int Max( int A, int B ) 
{ 
    return ( A >= B ) ? ( A ) : ( B ); 
}

1
2
3
4
5
template<typename T> 
T Max( T A, T B ) 
{ 
    return ( A >= B ) ? ( A ) : ( B ); 
}

Max<int>( 1, 2 );

1
2
3
4
5
6
7
8
class Test 
{ 
}; 
  
Test a; 
Test b; 
  
Max<Test>( a, b );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <iostream>   
  
template<typename T> class Exemple; 
  
template<typename T> 
std::ostream& operator<<(std::ostream&, Exemple<T> const&); 
  
template <typename T>   
class Exemple   
{   
public :   
  
    Exemple(const T& Val = T());   
  
    template <typename U>   
    Exemple(const Exemple<U>& Copy);   
  
    const T& Get() const;   
  
    // Spécialisation template <> selon le type T 
    friend std::ostream& operator << <>(std::ostream& Stream, const Exemple<T>& 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;   
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 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"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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

1
2
3
4
5
6
7
8
template <typename T> 
void Fonction( T x )  
{  
}  
  
Fonction<double>(5.2f);  
// Equivalent à  
Fonction( 5.2 );

1
2
3
4
5
6
7
8
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

1
2
3
4
5
6
7
8
9
10
11
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// exemple.h 
  
#ifndef EXEMPLE_H 
#define EXEMPLE_H 
  
template <typename T> 
class Exemple 
{ 
public: 
    Exemple(); 
}; 
  
#include "exemple.tpp" // <-- astuce ici !!! 
#endif

1
2
3
4
5
6
// exemple.tpp 
  
template <typename T> 
Exemple<T>::Exemple() 
{ 
}

1
2
3
4
5
template <typename /* ou class */ T> 
class MaClasse 
{ 
    ... 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
template <class T> 
class MaClasse 
{ 
public : 
    typedef int MonType; 
}; 
  
template <class T> 
void MaFonction(T x) 
{ 
    MaClasse<T>::MonType t; 
    ... 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
template <> 
class MaClasse<int> 
{ 
public : 
    static const int MonType = 5; 
}; 
  
template <class T> 
void MaFonction(T x) 
{ 
    MaClasse<T>::MonType t; // Que se passe-t-il ici si T est int ?? 
    ... 
}

1
2
3
4
5
6
template <class T> 
void MaFonction(T x) 
{ 
    typename MaClasse<T>::MonType t; 
    ... 
}

1
2
3
4
5
6
7
template <class 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 
};

1
2
3
4
5
#include <vector> 
  
typedef std::vector Tableau; // erreur de compilation 
  
Tableau<int> t;

1
2
3
4
5
6
7
8
9
#include <vector> 
  
template <typename T> 
struct Tableau 
{ 
    typedef std::vector<T> type; 
}; 
  
Tableau<int>::type t;

1
2
3
4
5
6
7
8
9
10
11
12
13
template <typename T> struct ValeurNulle; 
  
template <> struct ValeurNulle<int>         {static int Zero()         {return 0;}}; 
template <> struct ValeurNulle<std::string> {static std::string Zero() {return "";}}; 
template <> struct ValeurNulle<MaClasse>    {static MaClasse Zero()    {return MaClasse(-1);}}; 
// ... 
  
template <typename T> 
void Fonction(T Valeur) 
{ 
    T Ret = ValeurNulle<T>::Zero(); 
    // ... 
}

1
2
3
4
5
6
7
8
9
template <typename T> 
T Accumulation(const T* Debut, const T* Fin) 
{ 
    T Resultat = 0; 
    for ( ; Debut != Fin; ++Debut) 
        Resultat += *Debut; 
  
    return Resultat; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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); 
}

1
2
3
4
5
6
7
8
9
10
11
12
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; 
    } 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
template <typename T> 
class Mere 
{ 
    /* ... */ 
}; 
  
// soit la classe fille doit aussi être template comme ici 
template <typename T> 
class Fille1 : public /*ou private/protected */ Mere<T> 
{ 
    /* ... */ 
}; 
  
// soit on fixe le paramètre template 
class Fille2 : public Mere<int> // où n'importe quel type à la place de int 
{ 
    /* ... */ 
}; 
  
// ou encore 
class Fille3 : public /* ... */ Mere<Fille3>  
{ 
    /* ... */ 
};

1
2
3
4
5
6
7
8
9
10
template <class Derived> 
class Base 
{ 
    /* ... */ 
}; 
  
class Fille : public Base<Fille> 
{ 
    /* ... */ 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
template <typename T> 
struct counter 
{ 
    counter() 
    { 
        objects_created++; 
        objects_alive++; 
    } 
  
    counter(const counter& other)  
    {  
        objects_created++;  
        objects_alive++; 
    } 
  
    virtual ~counter() 
    { 
        --objects_alive; 
    } 
    static int objects_created; 
    static int objects_alive; 
}; 
template <typename T> int counter<T>::objects_created( 0 ); 
template <typename T> int counter<T>::objects_alive( 0 ); 
  
class X : counter<X> 
{ 
    // ... 
}; 
  
class Y : counter<Y> 
{ 
    // ... 
};

1
2
3
4
5
6
7
8
template <class derived_widget> 
class widget 
{ 
public: 
    // ...  
    void show() { static_cast<derived_widget*>(this)->do_show(); } 
    // ... 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class button : public widget<button> 
{ 
    // ... 
private: 
    friend class widget<button>; // on donne à widget<button> l'accès à notre do_show() qui est private 
    void do_show() { std::cout << "Button" << std::endl; } 
}; 
  
class textfield : public widget<textfield> 
{ 
    // ... 
private: 
    friend class widget<textfield>; 
    void do_show() { std::cout << "Textfield" << std::endl; } 
};

1
2
3
4
button b("Cliquez ici"); 
textfield t("Entrez du texte ici"); 
b.show(); // affiche "Button" 
t.show(); // affiche "Textfield"

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Test  
{ 
    typedef int type; 
}; 
  
template < typename T >  
void f( typename T::type ) {} // definition #1 
  
template < typename T >  
void f( T ) {}                // definition #2 
  
f< Test > ( 10 ); //appelle #1  
f< int > ( 10 );  //appelle #2 sans erreur grace a SFINAE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
template <class PolicyT> 
class Host : public PolicyT 
{ 
  public: 
    void foo() { std::cout << 42 << std::endl; } 
}; 
  
class PolicyTImpl1 
{ 
  public: 
    void bar() { std::cout << "Forty-Two" << std::endl; } 
}; 
  
class PolicyTImpl2 
{ 
  public: 
    void bar() { std::cout << "Chuck Norris" << std::endl; } 
    void foobar() { std::cout << "C++" << std::endl; } 
}; 
  
// ... 
Host<PolicyTImpl1> h1; 
h1.foo(); // affiche 42 
h1.bar(); // affiche "Forty-Two" 
h1.foobar(); // ne compile pas 
  
Host<PolicyTImpl2> h2; 
h2.foo(); // affiche 42 
h2.bar(); // affiche "Chuck Norris" 
h2.foobar(); // affiche "C++"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
template <class ComputingLibraryPolicy> 
class Computing : public ComputingLibraryPolicy 
{ 
public: 
    // ... 
}; 
  
class FastComputingLibrary 
{ 
public: 
    float sin(float); 
    float cos(float); 
    float fast_sin(float); 
    float fast_cos(float); 
    // ... 
}; 
  
class ComputingLibrary 
{ 
public: 
  float sin(float); 
  float cos(float); 
}; 
  
// ... 
  
#ifdef SYS_EXPLOITATION_A 
typedef Computing<FastComputingLibrary> computing_type; 
#else 
typedef Computing<ComputingLibrary> computing_type; 
#endif 
  
// ... 
  
computing_type comp; 
comp.fastsin(0); // compilera sur l'OS A uniquement 
comp.sin(0); // compilera sur les deux plateformes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
template <class Computation> 
void do_something()  
{  
    std::time_t start = time(NULL); 
    Computation::compute(); 
    std::time_t end = time(NULL); 
    std::cout << end - start << " seconds." << std::endl; 
} 
  
struct SingleThreadedComputation 
{ 
    static void compute() 
    {  
        // implémentation monothread 
    } 
}; 
  
struct MultiThreadedComputation 
{ 
    static void compute() 
    {  
        // implémentation multithread 
    } 
}; 
  
// par exemple : 
#ifdef STCOMPUTATION 
do_something<SingleThreadedComputation>(); 
#elif defined MTCOMPUTATION 
do_something<MultiThreadedComputation>(); 
#endif 
  
// comportement que l'on peut choisir soit avec un #define,  
// soit avec l'option de compilation -DSTCOMPUTATION ou -DMTCOMPUTATION

1
2
3
4
template<typename T> 
void bar() { 
    // T::element 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <iostream> 
  
struct A 
{ 
    static const int value = 5; // 1 
  
    using type = double; // 2 
  
    template <typename T> struct B // 3 
    { 
        void fct() const { std::cout << "B::fct" << std::endl; } 
    }; 
  
    template <typename T> // 4 
    void foo() const { std::cout << "A::foo" << std::endl; } 
}; 
  
  
template <class U, class T> void bar(const T& a) 
{ 
    std::cout << T::value << std::endl; // 1 
  
    typename T::type d = 0.5; // 2 
    std::cout << 2*d << std::endl; 
    /* sans typename : 
    main.cpp:23:18: error: need 'typename' before 'T:: type' because 'T' is a dependent scope 
    main.cpp:23:18: error: dependent-name 'T:: type' is parsed as a non-type, but instantiation yields a type 
    main.cpp:23:18: note: say 'typename T:: type' if a type is meant */ 
  
    typename T::template B<int> b; // 3 
    b.fct(); 
    /* sans template : 
    main.cpp:30:17: error: non-template 'B' used as template 
    main.cpp:30:17: note: use 'T::template B' to indicate that it is a template 
    main.cpp:30:17: error: declaration does not declare anything [-fpermissive] */ 
  
    a.template foo<U>(); // 4 
    /* sans template : 
    main.cpp:37:14: error: expected primary-expression before '>' token 
    main.cpp:37:16: error: expected primary-expression before ')' token */ 
} 
  
int main(void) 
{ 
    bar<bool>( A() ); 
    return 0; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
template <typename T> 
class Mere 
{ 
protected : 
  
    T membre; 
}; 
  
template <typename T> 
class Fille : public Mere<T> 
{ 
public :  
    // On souhaite utiliser la variable 'membre' définie dans la 
    // classe 'Mere<T>' : 
  
    // 1) On peut utiliser 'this->' pour préciser qu'il s'agit d'un 
    // membre de cette classe (le compilateur peut alors 
    // regarder dans la classe mère s'il existe bel et bien). 
    T MereMembre1() 
    { 
        return this->membre; 
    } 
  
    // 2) On peut écrire explicitement 'Mere<T>::'. 
    // Attention cependant pour les fonctions membres : cette 
    // syntaxe appellera toujours la version de 'Mere<T>', 
    // même si cette méthode est virtuelle et ré-implémentée 
    // ailleurs. 
    T MereMembre2() 
    { 
        return Mere<T>::membre; 
    } 
  
    // 3) Enfin, on peut utiliser une directive 'using'. Cette 
    // dernière méthode est la plus verbeuse dans notre cas 
    // simple. Cependant, une fois la directive écrite, toutes les 
    // références à 'membre' dans le reste du code de cette 
    // classe n'auront plus à être qualifiées explicitement. 
    using Mere<T>::membre; 
    T MereMembre3() 
    { 
        return membre; 
    } 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream> 
  
template<typename T> 
class Mere 
{ 
public : 
  
    T membre; 
}; 
  
int membre = 4;   
  
template<typename T> 
class Fille : public Mere<T> 
{ 
public : 
  
    T MereMembre() 
    { 
        return membre; 
    } 
}; 
  
int main() 
{ 
    Fille<int> f; 
    f.membre = 5; 
    std::cout << f.MereMembre() << std::endl; 
}