Pb de Template

Version imprimable

Pb de Template

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

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:

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.
@+

07/09/2006, 22h38
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) ...

Code:

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.

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:

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:

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:

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:

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:

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:

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 ;)

08/09/2006, 02h02
loufoque

Citation:

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

C'est quoi cette idée tordue d'instancier des classes avec new ?
08/09/2006, 02h25
koala01

Citation:

Envoyé par loufoque

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:

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 ;) :P
08/09/2006, 08h07
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:

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:

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.
08/09/2006, 09h07
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é.

Citation:

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*".

Citation:

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:

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.

@+
08/09/2006, 09h31
Jean-Marc.Bourguet
Citation:

Envoyé par olive_le_malin

--> 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é.

Citation:

--> 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*?).

Citation:

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

Citation:

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.
Citation:
La solution à mon pb est donc d'écrire ce qu'à conseillé Loufoque" :

Code:

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.
08/09/2006, 10h04
olive_le_malin

Bonjour,

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

@+
08/09/2006, 10h08
Jean-Marc.Bourguet

Citation:

Envoyé par olive_le_malin

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?
08/09/2006, 10h11
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 ...

et bien ce que j'aimerais c'est utiliser qqch de générique, et donc aussi bien passer en template un char*, qu'un CString, ou qu'un int ... mais j'ai l'impression qu'on ne peut pas ...

Voilà le code que j'ai écrit :

Code:

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<typename T>
class CMaillon
{
private:
	T* m_info;
	CMaillon* m_suiv;
 
public:
	//Constructeur
	CMaillon(const T& x, CMaillon* s) : m_suiv(s) {
		m_info = new T;
		*m_info = x;
	//	suiv = s;
	}
 
	//Constructeur par copie
	CMaillon(const CMaillon& m) {
		m_info = m.m_info;
		m_suiv = m.m_suiv;
	};		
 
	//Opérateur d'affectation
	CMaillon& operator= (const CMaillon& m)
	{		
		if(this != &m)
		{
			m_info = m.m_info;
			m_suiv = m.m_suiv;
		}
		return *this;
	}
 
	~CMaillon(){
		delete [] m_info;
	};
};

08/09/2006, 11h03
Jean-Marc.Bourguet
Tu t'obstines avec les pointeurs...

Essaies d'abord de faire fonctionner ton template avec des objets ayant une sémantique de valeur, ensuite tu pourras réfléchir à ce que tu veux quand tu as un pointeur:
- copier simplement le pointeur;
- copier l'objet pointé;
- copier un tableau, mais de quelle taille? Les char* représentant des chaînes sont terminés par un '\0', mais les autres?
et éventuellement jouer avec les spécialisations pour avoir ce tu veux. Mais un conteneur de char* qui se comporte différemment d'un conteneur de int*, c'est une mauvaise idée à mon avis.
08/09/2006, 11h37
Alp

Ou alors c'est une std::string, si le conteneur de char a une visée équivalente à std:string, et dans ce cas là CMaillon n'est pas vraiment la classe appropriée pour implémenter ça.
En effet, pourquoi toujours mettre ton pointeur pour info?
T info;
n'irait pas?

Citation:

En effet, pourquoi toujours mettre ton pointeur pour info?
T info;
n'irait pas?

Si, c'est bien ce que j'avais fait au début, mais comment rendre générique à l'utilisation d'un char* ET d'un std::string, ou d'un CString ?

En effet si je me dis que je n'utilise que des objets ayant une sémantique de valeur, je n'ai plus de problème.

Le code devient donc :
Code:

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> class CMaillon { private: T m_info; CMaillon* m_suiv; public: //Constructeur CMaillon(const T& x, CMaillon* s) : m_info(x), m_suiv(s) { } //Constructeur par copie CMaillon(const CMaillon& m) { m_info = m.m_info; m_suiv = m.m_suiv; }; //Opérateur d'affectation CMaillon& operator= (const CMaillon& m) { if(this != &m) { m_info = m.m_info; m_suiv = m.m_suiv; } return *this; } ~CMaillon(){ }; };
@+