Discussion :

[tintin72]

Bonjour,

Je m'initie aux templates mais certains points me paraissent confus
et je m'embrouille, (je crois qu'en fait j'ai tendance à faire une confusion
entre les templates et typedef)
Je vais prendre un bout d'exemple classique de liste chainée générique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
template <typename T> class CList;
 
template <typename TYPE> class CElement
{
   friend class CList<TYPE>;
 
   private :
       //CONSTRUCTEURS
       CElement() {next = prev = NULL;}
 
       CElement(const TYPE &d)
       {
         data = d;
         next = prev = NULL;
       }
 
       //VARIABLES MEMBRES
       TYPE data;             //L'information contenue dans l'élément.
       CElement<TYPE> *next;  //L'adresse de l'élément suivant.
       CElement<TYPE> *prev;  //L'adresse de l'élément précédent.
};

Je comprend la variable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
TYPE data;

où TYPE est remplacé par le type que l'on veut manipuler int, double etc....
mais je comprend moins le sens de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
CElement<TYPE> *next;

et encore moins

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
friend class CList<TYPE>;

puisque dans la déclaration (plus haut) typename est définit par T et non pas TYPE
Je suppose que dans ce cas TYPE n'est plus un alias censé être remplacé par le type qu'on veut utiliser.
Est ce une convention pour dire au compilo qu'il a affaire à une classe "templatisée" ?

Si quelqu'un pouvait m'éclairer.

Merci d'avance

[koala01]

Salut,

En gros, la seule différence entre une classe template et une classe classique, c'est que les types utilisé dans la classe template ne seront déterminés... qu'une fois que la classe est utiliée...

L'encapsulation et la visibilité des données n'est absolument pas modifiée par le fait que tu travailles sur une classe template...

De cette manière, si tu crées deux classes (non template) sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
class ElementInt
{ 
       /*(... tous des choses qui s'accordent avec des entiers)*/
};
class ListInt
{
    friend class ElementInt;
/* tout ce qu'il faut pour ta liste d'entier */
};

Le type de tout ce que tu peux avoir écrit dans ElementInt est connu (et s'accorde avec le type int)

Tu créeras donc ta classe ListeInt... pour qu'elle puisse travailler avec ... des entiers (vu que c'est le type qui va bien avec ElementInt...)

Seulement, voilà...

En y réfléchissant, tu te dis que, ta classe Element, elle peut aussi bien contenir des entiers que des doubles... et, qu'à bien y réfléchir, ce pourrait aussi bien etre des éléphants ou des chimpanzées...

Tu va donc dire au compilateur

je n'ai pas encore décidé le type des objets Element devra gérer, mais je sais déjà la manière dont ca fonctionnera... en attendant, on va dire que ce sera le type T

et tu va créer ta classe Element sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
template <typename T>
class Element
{
   /* ce qui va bien avec, en utilisant le type "T" */
};

Et tu fais pareil avec ta classe List...
Simplement, tu lui dit que, dans le cadre de liste le type qui sera utilisé est... TYPE (apres tout, pourquoi pas)...

Simplement, tu aurais peut etre eu plus facile, et cela aurait peut etre moins prété à confusion, si le nom donné au type non identifié avait été le même

Seulement voilà... T n'est connu comme "type qu'on n'a pas encore identifié" que dans Element, et TYPE n'est connu que comme type qu'on n'a pas encore identifié que dans ... List...

Mais, ce fameux type "non identifié", il est le meme si la Liste et Element travaillent de concert...

Tu décides donc de déclarer Element comme ami de List... Soit... mais, Element, il attend toujours qu'on lui dise avec quel type travailler...

Donc, quand tu écrit la ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

friend class Element</* il faut quelque chose ici */ >

le "quelque chose" qui manque va permettre de préciser le type à utiliser à élément...

Encore faut il que le type à utiliser soit connu de... Listet, comme il n'y aurait aucun sens d'utiliser des entiers d'un coté et des chimpanzées de l'autre, ben, le "type qui ira bien pour Entier et pour List" n'est autre... que TYPE...

C'est la raison pour laquelle ta déclaration d'amitié devient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
friend class Element<TYPE>

[loufoque]

T et TYPE sont des variables muettes.

C'est comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int f(int x)
{
    return x*x;
}

est la même chose que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int f(int y)
{
     return y*y;
}

Et c'est pas parce que la fonction est définie en terme de x ou y que tu ne peux pas l'appeler avec une variable qui s'appelle z...