Discussion :

[olive_le_malin]

Bonjour,
pour rendre générique une classe, j'aimerais utiliser un template.

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
 
class CMaillon
{
private :
 char* info;
 CMaillon* suiv;
 
public:
CMaillon(char* x, CMaillon* s) {
  info = new char[strlen(x) + 1];
  strcpy(info, x);
  suiv = s;
 
~CMaillon() {
 delete info;
}
}

Donc j'aimerais que cette classe soit utilisable pour n'importe quel objet.

Je voulais faire qqchose comme ça :

Code :

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

1
2
3
4
5
6
7
 
template< typename T>
class CMaillon
{
...
CMaillon(T x, CMaillon* s);
}

Mais du coup, comment vais-je faire mon allocation de la variable info en utilisant un template ?

Merci par avance.
@+

[Alp]

En instanciant ta variable info de type T ... ?
Soit :
info = new T(args du constructeur);
soit dans la liste d'initialisation, avec info(args du constructeur) ...

[loufoque]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template <typename T>
class CMaillon
{
private :
 T info;
 CMaillon* suiv;
 
public:
CMaillon(const T& x, CMaillon* s) : info(x), suiv(s){
}
};

Ce qui met en évidence le manque d'intérêt de ton code.

[koala01]

Salut,

Quand tu utilises les modeles (je trouve ce terme plus "francais" que celui de template ), le principe reste toujours le meme:

il faut que tu fournisse un type générique, et que tu l'utilises partout où tu veux la généricité.

Cela signifie que, si tu définis ta classe sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
 
typedef <typename T>
MaClasse
{
    MaClasse()
   (...)
   T Donnee
   (...)
   Fonction(T *intro)
};

Il faudra indiquer pour chaque bloc de déclaration/implémentation qu'il doit utiliser le type générique.

Autrement dit, pour la déclaration, le template <typename T> s'applique dans l'ensemble de la déclaration de ta classe,et ca passera si tu décides d'implémenter les méthodes directement dedans sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
 
template <typename T>
class MaClasse
{
    MaClasse(T&)
        {
            //implémentation du constructeur
        }
};

Si tu décide de déporter l'implémentation (dés qu'elle sort du bloc déclarant la classe, il faudra le faire sous la forme de

Code :

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

1
2
3
4
5
6
 
template <typename T>
Maclass<T>::Fonction(T *intro )
{
    //implémentation de la méthode
}

L'héritage pourrait se faire de deux manières

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
// la classe dérivée est, elle aussi, une classe modèle
template <typename T>
class Derivee: public MaClasse<T>
{
   ...
};
// ou la classe hérite d'un modèle dont le type est connu
classe Derivee:public MaClasse<int>
{
 
};

et que, enfin, l'instanciation se fasse en indiquant le type à utiliser sous la forme de

Code :

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

1
2
 
MaClasse *objet=new MaClasse<le type souhaité>(les arguments éventuels);

Pour l'instanciation, si la synthaxe MaClasse<Type à utiliser> te parrait réellement trop complexe, ce qui peut arriver, par exemple, lorsque tu as plusieurs type à préciser, et que certains sont, eux-memeq, des modèles, ou, tout simplement, parce que tu prévois de travailler souvent avec ta classe modèle utilisant un type précis, il est peut etre intéressant de déclarer un nouveau type sous la forme de

Code :

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

typedef MaClasse<int> MaClasseInt;

(le débat fait rage, mais il vaut mieux utiliser typedef que l'instruction préproc #define ) et de travailler alors avect MaClasseInt.

J'ai sciemment pris certains raccourcis et laissé quelques imprécisions sur le coté parce que le post devenait déjà grand... le principal étant AMHA que tu puisse comprendre "en gros" l'utilisation de tes templates

[loufoque]

MaClasse *objet=new MaClasse<le type souhaité>(les arguments éventuels);

C'est quoi cette idée tordue d'instancier des classes avec new ?

[koala01]

C'est quoi cette idée tordue d'instancier des classes avec new ?

Et pourquoi pas, d'abord???

Si, pour une raison ou un autre, tu as besoin de gérer cet objet de manière dynamique, c'est une manière de faire qui en vaut une autre...

D'autant plus que, quand on voit la classe présentée en exemple dans la question de olive_le_malin, il s'agit clairement d'une liste ou d'une file, et que, dans ce genre de cas, tu n'as pas beaucoup d'autre solutions pour la gérer (si tu décide de ne pas utiliser la STL, du moins)...

Edit==>Au fait, mais, tu ne l'a peut etre pas remarqué parce que, effctivement j'ai fait une petite erreur dans le code qui devrait etre

Code :

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

MaClasse<le type souhaité> *objet=new MaClasse<le type souhaité>(les arguments éventuels);

mais j'utilise ici un pointeur, et, jusqu'à preuve du contraire, instancier dynamiquement un pointeur sur un objet, ca se fait avec new

[Jean-Marc.Bourguet]

Naturellement, la question de fond c'est pourquoi ne pas utiliser std::string qui est le type des chaînes de caractères en C++ ou std::vector qui est le type des tableaux? En poussant plus loin, pourquoi ne pas utiliser simplement std::list plutôt que d'inventer un type de liste de plus?

Et utiliser std::string aurait vraissemblablement évité le problème de chercher comment allouer info dans la version template: tu n'aurais pas eu l'idée de faire de l'allocation dynamique pour un std::string employé comme cela.

Quelques remarques supplémentaires:

Tu fais:

Code :

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

1
2
3
info = new char[strlen(x) + 1];
...
delete info;

Pour libérer quelque chose qui a été alloué avec new[], il faut utiliser delete[], donc

Code :

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

delete [] info;

Tu laisses le constructeur par copie et l'opérateur d'assignement à leur version définie par le compilateur alors que le destructeur fait quelque chose, c'est mauvais signe et effectivement tu risques de libérer deux fois de la
mémoire et d'avoir des fuites.

C'est généralement pas une très bonne idée de passer par valeur des arguments dont le type est déterminé par un paramètre template, une référence constante va éviter des copies potentiellement coûteuses.

[olive_le_malin]

Bonjour,
Merci à vous tous, notamment Koala01 pour tes explications générales sur les "Modèles"

Jeans-Marc.Bourguet :

--> pour le delete je pensais que [] était utilisé si on libérait un tableau alloué.

Naturellement, la question de fond c'est pourquoi ne pas utiliser std::string qui est le type des chaînes de caractères en C++ ou std::vector qui est le type des tableaux? En poussant plus loin, pourquoi ne pas utiliser simplement std::list plutôt que d'inventer un type de liste de plus?

Et utiliser std::string aurait vraissemblablement évité le problème de chercher comment allouer info dans la version template: tu n'aurais pas eu l'idée de faire de l'allocation dynamique pour un std::string employé comme cela.

--> Et oui je m'attendais à cette remarque

--> Mais disons que pour commencer à utiliser les template et à comprendre leur fonctionnement, (car vous aurez compris que je débute avec), je migre une liste chainée de strings déjà écrite avec un type "char*".

Tu laisses le constructeur par copie et l'opérateur d'assignement à leur version définie par le compilateur alors que le destructeur fait quelque chose, c'est mauvais signe et effectivement tu risques de libérer deux fois de la
mémoire et d'avoir des fuites.

C'est généralement pas une très bonne idée de passer par valeur des arguments dont le type est déterminé par un paramètre template, une référence constante va éviter des copies potentiellement coûteuses.

--> Donc de manière générale, tu me conseilles de définir en plus le constructeur par copie, l'opérateur d'assignement, et de passer plutôt des références constantes.


La solution à mon pb est donc d'écrire ce qu'à conseillé "Loufoque" ? :

Code :

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

1
2
3
 
CMaillon(const T& x, CMaillon* s) : info(x), suiv(s){
}

Mais là non plus, info n'est pas alloué ... Donc je ne sais pas commment faire.

@+

[Jean-Marc.Bourguet]

--> pour le delete je pensais que [] était utilisé si on libérait un tableau alloué.

Comment veux-tu qu'en général le compilateur sache quel version de new a été utilisée? Ce n'est peut-être pas dans la même unité de compilation, ça dépend peut-être du chemin dans lequel on est passé.

--> Mais disons que pour commencer à utiliser les template et à comprendre leur fonctionnement, (car vous aurez compris que je débute avec), je migre une liste chainée de strings déjà écrite avec un type "char*".

Un exercice pour comprendre comment fonctionne les templates, c'est une raison valable de réinventer la roue. A condition d'en être conscient.

Mais ça n'explique pas l'utilisation de char* pour les chaînes (au strict minimum, pourquoi pas char const*?).

--> Donc de manière générale, tu me conseilles de définir en plus le constructeur par copie, l'opérateur d'assignement,

Quand tu définis un destructeur, il est rare de ne pas avoir à au moins déclarer le constructeur par copie et l'assignement. Maintenant que tu les définisses en plus ou non ou que tu les déclares privés, c'est un choix de conception. Dans le cas de chaînons, j'aurais tendance à les déclarer privés et à ne pas les implémenter.

et de passer plutôt des références constantes.

En général, j'utilise des références constantes pour tout ce qui n'est pas type de base -- et les arguments templatisés n'en sont pas -- sauf quand j'ai une bonne raison de faire autrement.

La solution à mon pb est donc d'écrire ce qu'à conseillé Loufoque" :

Code :

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

1
2
CMaillon(const T& x, CMaillon* s) : info(x), suiv(s){
}

Et je suppose d'y ajouter les constructeurs et opérateurs manquants.

Oui.

[olive_le_malin]

Bonjour,

mais je ne comprends toujours pas comment allouer mon "T info" ... ?

@+

[Jean-Marc.Bourguet]

Bonjour,

mais je ne comprends toujours pas comment allouer mon "T info" ... ?

@+

Qu'est-ce que tu ne comprends pas dans le message numéro 3 de la discussion?

[Alp]

Si c'est un pointeur, tu dois l'initialiser avec new T(arguments).
Si c'est un objet statique, tu dois l'initialiser dans la liste d'initialisation en faisant :
Construct(...) : info(arguments), etc ...