Classe template générique

Version imprimable

Bonjour à tous,

J'ai encore quelques difficultés (si ce n'est beaucoup :aie:) à comprendre les templates. Est-il possible, via ces derniers de créer une classe générique comme cela (la représentation est bien sur grossière) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class A { template<typename U, typename V>map<U,V> list; template<typename U, typename V> void Add_Data(U key, V value) { list.insert(pair<U,V>(key,value)); } template<typename U, typename V> V Get_Data(U key) { return *(list.find(key)); } }
merci d'avance :D

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<typename U, typename V>
class A
{
map<U,V> list;
 
void Add_Data(U key, V value) 
{ 
list.insert(pair<U,V>(key,value));
}
 
V Get_Data(U key) 
{
return *(list.find(key));
}
}

est la bonne maniere

09/08/2011, 22h09
gilims
Merci pour la rapidité de la réponse Joel !

C'était à peu près ce que j'avais compris de l'histoire, je suis pas si nul que ca en fin de compte :P.
Cependant, cela implique une autre problématique car pour utiliser cette classe A avec toutes les combinaisons de types <U,V>, il m'est nécessaire de devoir définir une nouvelle variable à chaque fois, ce qui est embêtant. Par exemple :
Code:

1 2 3 4 5 6 7 8 class B { private: A<bool,int> t1; A<string,bool> t2;// etc etc }
Ce qui devient lourds si on doit gérer toutes les combinaisons.

N'y-t-il pas un moyen de gérer ca avec une seule variable ? J'ai cru comprendre que boost::variant était une solution...
10/08/2011, 00h01
koala01

Salut,

Il faut faire attention au fait que, lorsque tu crées une classe template et qu'elle n'hérite pas d'une classe de base qui ne serait pas template, une instance de type TaClass<A, B> n'a strictement rient à voire (hormis l'interface et le comportement) avec une instance de type TaClass<C, D>, ni même seulement avec une instance de type TaClass<A, C>...

Ce que je veux dire par là, c'est que tu ne pourras absolument pas envisager de créer une collection d'objets qui contiendrait une instance de TaClass<A, B> et une instance de TaClass<C, D> .

Le but des template est d'autoriser l'utilisation du paradigme dit "générique", c'est à dire un moyen qui te permettra d'écrire peu de code, mais de le faire s'adapter à de nombreuses situations quant aux types utilisés, pour autant que les types en question respectent une interface donnée.

Si le but est, comme ta question semble le suggérer, de pouvoir profiter de la substituabilité des différents types, il faudra de toutes manière en arriver à avoir une classe de base commune, avec l'héritage qui va bien...

Au risque de paraitre têtu (désolé par avance koala01), j'ai essayé quelque chose. Ca en marche pas bien sur, sinon ca aurait été trop facile. Je veux juste saisir ce concept de template.

Le Point.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
typedef boost::variant<int ,double> IType;
 
class Point : public Coords
{
private:
    Datas<unsigned int,IType > idata;
public:
    Point(const double _x, const double _y, const double _z);
    virtual ~Point(){}
    virtual string __ToString(const bool _parent=false) const;
    template<typename T> bool AddData(const unsigned int tag, const T t);
    template<typename T> const T &GetData(const unsigned int tag) const;
 
};

Le Point.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Point::Point(const double _x, const double _y, const double _z):Coords(_x,_y,_z)
{
}
 
    string Point::__ToString(const bool _parent) const
    {
    ostringstream oss;
    if (!_parent) oss << "########## COORDS ##########"<<endl;
    oss.precision(4);
    oss << "("<<_x()<<";"<<_y()<<";"<<_z()<<")"<<endl;
    return oss.str();
    }
   template<typename T> bool Point::AddData(const unsigned int tag, const T t)
 
    { idata.Add_Data(tag,t); return true;}
 
    template<typename T> const T & Point::GetData(const unsigned int tag) const
    {
	idata.Get_Data(tag);
    }

Le datas.h

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
 
#include <map>
using namespace std;
template<typename U, typename V>class Datas
{
private:
    map<U,V> list;
public:
    Datas(){}
    void Add_Data(U key, V value)
    {
    list.insert(pair<U,V>(key,value));
    }
 
    V Get_Data(U key)
    {
    return *(list.find(key));
    }
 
    void Remove_Data(U key)
    {
	list.erase(list.find(key));
    }
};

et le main :

Code:

1
2
3
4
5
 
int main(){
    Point c(1,2,3);
    c.AddData(3, 2.1);
}

Pourquoi il me sort ca lors de la compilation :

Code:

1
2
3
Undefined symbols:
  "bool ICMole::Point::AddData<double>(unsigned int, double)", referenced from:
      _main in main.o

...:aie:

10/08/2011, 16h15
3DArchi
Salut,
Citation:
Envoyé par gilims

Pourquoi il me sort ca lors de la compilation :

Code:

1 2 3 Undefined symbols: "bool ICMole::Point::AddData<double>(unsigned int, double)", referenced from: _main in main.o

...:aie:
F.A.Q. : Pourquoi mes templates ne sont-ils pas reconnus à l'édition des liens ? . C'est aussi vrai pour les fonctions membres template d'une classe non template.

Au passage :
:fleche:__ToString : Quels sont les identificateurs interdits par la norme ?

:fleche: Pas de using namespace dans un fichier d'en-tête F.A.Q: Quand utiliser / ne pas utiliser using namespace ?

:fleche: virtual string __ToString c'est très bof (ça sent le java à plein nez:mouarf:) La sérialisation en chaîne je n'aime pas trop l'avoir dans la classe. En plus ça sent la fonction d'un SuperObject duquel vont dériver tout tes objets. Bref, pas terrible d'un point de vue design

:fleche: class Point : public Coords J'ai du mal avec ça. A priori, Point (et Coords) ont une sémantique de valeur et non d'entité incompatible avec de l'héritage. Respectes-tu bien le LSP (héritage EST-UN) ? Ou les classes sont mal nommées ou le design est hasardeux.

:fleche: L'héritage se marie mal avec la copie. J'espère que Coords interdit la copie ;)

:fleche: J'aurais mis typedef boost::variant<int ,double> IType; dans la classe :
Code:

1 2 3 4 5 class Point : public Coords { typedef boost::variant<int ,double> IType;
10/08/2011, 16h26
bountykiler
Plusieurs remarques:
- Pour ta classe Data, je ne vois pas trop à quoi elle sert. Pour moi, tu peux utiliser une std::map directement.
-
Code:

1 2 3 Undefined symbols: "bool ICMole::Point::AddData<double>(unsigned int, double)", referenced from: _main in main.o
Pour info, ce n'est pas un problème à la compilation mais bien à l'édition de liens. C'est une erreur classique quand on apprend à utiliser les templates (je l'ai faite avant toi ;) ) Voir la faq pour plus d'infos.

(EDIT : grilled :oops:)

- Ta variable idata va contenir des valeurs qui seront soit des entiers, soit des doubles, chaque valeur étant indéxée via un entier non signé. Est-ce bien là ce que tu veux faire?

- Pour ton code :
Code:

1 2 3 4 5 6 7 8 12345678 class B { private: A<bool,int> t1; A<string,bool> t2;// etc etc }
ce qu'il faut que tu comprennes, c'est que

Code:

A<bool,int>

représente un type, et

Code:

A<string,bool>

représente un autre type.
Du coup, tes variables t1 et t2 sont bien de type différent, donc impossible de les stocker directement dans une même variable. L'utilisation de boost::variant peut effectivement aider, encore faut-il voir s'il s'agit bien de la solution la plus adaptée à ton problème.
23/09/2011, 15h12
gilims

Désolé pour le retard dans ma réponse, vacance oblige !

Merci bountykiler et 3DArchi pour vos réponses.

Après avoir pris du recul avec ca, je comprends finalement que cette classe template générique ne sert à rien !!

Citation:

class Point : public Coords J'ai du mal avec ça. A priori, Point (et Coords) ont une sémantique de valeur et non d'entité incompatible avec de l'héritage. Respectes-tu bien le LSP (héritage EST-UN) ? Ou les classes sont mal nommées ou le design est hasardeux.

J'ai aussi du mal avec ca :lol: !! Ils ont une sémantique d'entité et non de valeur (en tout cas je pense). La raison est que j'utilise ca pour des atomes, donc si je suis le faq, deux atomes ayant les mêmes coordonnées, (même si c'est impossible), reste deux atomes différents n'est-ce pas ?

Citation:

__ToString : Quels sont les identificateurs interdits par la norme ?
Pas de using namespace dans un fichier d'en-tête F.A.Q
virtual string __ToString

Citation:

L'héritage se marie mal avec la copie. J'espère que Coords interdit la copie

Coords interdit en effet la copie. Mais si j'ai besoin de copier un atome (car je copie la molécule par exemple), cela est-il faisable via une sémantique d'entité et de l'héritage ?

Pour les templates, je vais encore m'entrainer !!

Salut,

Citation:

Envoyé par gilims

Ils ont une sémantique d'entité et non de valeur (en tout cas je pense). La raison est que j'utilise ca pour des atomes, donc si je suis le faq, deux atomes ayant les mêmes coordonnées, (même si c'est impossible), reste deux atomes différents n'est-ce pas ?

Atome a effectivement une sémantique d'entité mais sa position a une sémantique de valeur ;)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 struct Position { // .... }; bool operator==(Position const&lhs, Position const&rhs); bool operator!=(Position const&lhs, Position const&rhs); bool operator+(Position const&lhs, Position const&rhs); // etc... class Atom { public: virtual ~Atom(); // si utilisé comme base d'héritage private: Atom(Atom const&); // = delete Atom&operator=(Atom const&); // = delete Position pos; }
Citation:

Envoyé par gilims

Coords interdit en effet la copie. Mais si j'ai besoin de copier un atome (car je copie la molécule par exemple), cela est-il faisable via une sémantique d'entité et de l'héritage ?

Normalement tu ne fais pas une copie mais tu créés une nouvelle instance d'atome démarrant avec un état identique... C'est en général fait avec un design pattern Prototype
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 #include <memory> class Atom { public: Atom(){} virtual ~Atom(); // si utilisé comme base d'héritage std::shared_ptr<Atom> Clone() { return std::shared_ptr<Atom>(do_Clone()); } private: virtual Atom* do_Clone() { return new Atom; } Atom(Atom const&); // = delete Atom&operator=(Atom const&); // = delete Position pos; }; class TelAtom : public Atom { public: TelAtom(){} private: TelAtom* do_Clone() { return new TelAtom; } };

30/09/2011, 11h27
gilims

Magnifique !! J'ai mis en place ce système et ca marche du tonnerre !!:ccool::ccool::ccool:
J'ai tenté de coupler ca avec des pointeurs intelligents à partir du lien sur les designs patterns et ca marche. Difficile à mettre en place la première fois mais c'est nickel !!
J'ai aussi réaliser quelques essais avec des fonctions templates, et ca fonctionne ... que demande le peuple !! :P

Par contre, j'ai un autre concept à mettre en place, sur le même principe et sur lequel j'aimerais avoir l'avis du forum (et le tien/votre ?). J'ouvre un autre post ou je le mets ici ?

En tout cas merci encore 3DArchi
30/09/2011, 21h00
3DArchi

Citation:

Envoyé par gilims

J'ouvre un autre post ou je le mets ici ?

Nouvelle question, nouveau fil de discussion ;)