classe, map ou structure?

Version imprimable

26/12/2007, 14h06
falynne

classe, map ou structure?

Bonjour et Joyeux Noel en retard!!:yaisse2:

Je butes depuis une semaine sur un problème de conception de structures et l'utilisation de C++.
J'ai deux classes (Matiere et Recette) qui hérite de ma classe Ingredient et d'autre part j'ai une classe Quantite qui est une classe abstraite.
Recette est constituée de composants qui sont en fait une composition d'Ingredient et de Quantite.
Au début j'ai donc créé une classe Composant, avec un attribut de type Ingredient et une autre de type Quantite, et Recette contenant un vector Composant*. Cela marchait très bien.
Mais dans mes composant il fallait qu'à un ingrédient corresponde une quantité et que je puisse accèder à ces attributs pour faire une comparaison avec un stock de composants.
J'ai donc voulu utiliser une map<Ingredient*,Quantite*>, mais une erreur de segmentation survenait.
Je suis alors passé à une structure composant avec un attribut de type Ingredient& et un Quantite& et cela ne fonctionne toujours pas (je ne comprends même pas l'erreur!).

Je ne sais plus quoi utiliser pour résoudre mon problème.Ou il y a t il une manière précise d'utiliser la map?ou la structure?

Merci d'avance pour vos suggestions.
26/12/2007, 16h38
ep31

Qu'est-ce qui ne marche pas exactement ?
Un problème de compilation, de modélisation, d'exécution ?
26/12/2007, 16h46
Pacorabanix

Citation:

J'ai deux classes (Matiere et Recette) qui hérite de ma classe Ingredient et d'autre part j'ai une classe Quantite qui est une classe abstraite.

une relation d'héritage peut se traduire habituellement en français par un "classe fille" est un "classe mère". Je comprend mal Recette est un ingrédient. Veux-tu dire qu'une recette a des ingrédients (c'est à dire Recette possède des objets membres ingrédients) ?

De plus si quantité est une classe abstraite tu en peux pas l'instancier, donc pas d'objets possibles, donc tu va difficilement pouvoir faire une map avec.

Sais-tu vraiment ce qu'est une map ?
26/12/2007, 16h51
Pacorabanix

Citation:

Envoyé par falynne

Au début j'ai donc créé une classe Composant, avec un attribut de type Ingredient et une autre de type Quantite

ne devrais-tu pas justement faire hériter ton composant de ingrédient et quantité ? comme je le lis ça a plus de sens (mais ce n'est que mon avis bien sur... ;) )
26/12/2007, 16h57
falynne

C'est un problème de compilation, j'utilise normalement la map ou la structure mais cela ne fonctionne pas.

Une recette est un ingredient, puisqu'elle est une classe fille d'ingredient, mais elle utilise aussi des ingrédients,ce qui ve dire qu'une recette peut utiliser une recette comme un de ces ingrédients.
Ma classe Quantité est effectivement une classe abstraite mais qui a comme classes filles Litre,Gramme et Unite.
Mais si je veux des composants (qui vont constitués ma recette),ingredients associés à des quantités, je suis obligé d'utiliser ma classe quantité?
26/12/2007, 17h02
falynne

Citation:

ne devrais-tu pas justement faire hériter ton composant de ingrédient et quantité ? comme je le lis ça a plus de sens (mais ce n'est que mon avis bien sur... )

je ne sais pas comment est ce que cela se passe dans ce cas, peux tu me l'expliquer s'il te plait, parce que d'après mon diagramme mon composant est une association d'Ingredient et quantite.
26/12/2007, 20h18
Pacorabanix
Citation:

Envoyé par falynne

Une recette est un ingredient, puisqu'elle est une classe fille d'ingredient, mais elle utilise aussi des ingrédients,ce qui ve dire qu'une recette peut utiliser une recette comme un de ces ingrédients.

ah oui, si on peut réutiliser une préparation comme ingrédient je comprend en effet.

Citation:

Envoyé par falynne

je ne sais pas comment est ce que cela se passe dans ce cas, peux tu me l'expliquer s'il te plait, parce que d'après mon diagramme mon composant est une association d'Ingredient et quantite.

pour faire dériver une classe de plusieurs autres, c'est très simple :
Code:

1 2 3 4 5 class Base1 {}; class Base2 {}; class Derivee : public Base1, public Base2 {};
Faut faire gaffe aux noms qui se marchent sur les pieds.
26/12/2007, 21h36
ep31

Citation:

Envoyé par Pacorabanix

une relation d'héritage peut se traduire habituellement en français par un "classe fille" est un "classe mère". Je comprend mal Recette est un ingrédient. Veux-tu dire qu'une recette a des ingrédients (c'est à dire Recette possède des objets membres ingrédients) ?

De plus si quantité est une classe abstraite tu en peux pas l'instancier, donc pas d'objets possibles, donc tu va difficilement pouvoir faire une map avec.

Sais-tu vraiment ce qu'est une map ?

Beh si 8O, c'est le principe même du polymorphisme.
26/12/2007, 21h38
ep31

Citation:

Envoyé par falynne

C'est un problème de compilation, j'utilise normalement la map ou la structure mais cela ne fonctionne pas.

Une recette est un ingredient, puisqu'elle est une classe fille d'ingredient, mais elle utilise aussi des ingrédients,ce qui ve dire qu'une recette peut utiliser une recette comme un de ces ingrédients.
Ma classe Quantité est effectivement une classe abstraite mais qui a comme classes filles Litre,Gramme et Unite.
Mais si je veux des composants (qui vont constitués ma recette),ingredients associés à des quantités, je suis obligé d'utiliser ma classe quantité?

Ce serait possible d'avoir la partie du code qui plante et les erreurs du compilateur svp ?

Recette.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
25
26
27
28
 
#ifndef RECETTE_H
 
#define RECETTE_H
 
 
 
#include <iostream>
 
#include <string>
#include <vector>
#include <map>
#include "ingredient.h"
#include "quantite.h"
#include "exception_recette_multiple.h"
class Recette : public Ingredient{
 
   private:
 
      std::string _explication; // corps de la recette
      int _tpsPreparation; // temps de la préparation de la recette
      Quantite& _parts; // composant de la recette
      typedef std::map<Ingredient&,Quantite&> Composant;
      std::vector<Composant*> ContComposant;// conteneur de composants
      int tps;
  public:
      void afficher(std::ostream&) const;
      void ajouter_composant(Quantite&,Ingredient&);

Recette.cpp

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
 
void Recette::ajouter_composant(Quantite& q,Ingredient& i) {
 
	tps=tps + i.temps_de_preparation();
        Composant ct;
	ct[i]=q;
	ContComposant.push_back(&ct);
 
	//ContComposant.push_back(new composant(i,q));
 
}
 
void Recette::afficher(ostream& os) const{
 
	os << Ingredient::nom() << " " << "(" << _parts << "," << " " << tps << " " <<"minutes" << ")" << endl;
 
	for (int i=0;i<ContComposant.size();++i){
		 os << *ContComposant[i];
 
	}
 
	os << _explication<< endl;
 
}

erreur:

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
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
65
66
67
68
69
70
71
 
/usr/include/c++/4.1.3/bits/stl_function.h: In instantiation of «std::less<Ingredient&>":
/usr/include/c++/4.1.3/bits/stl_tree.h:400:   instantiated from «std::_Rb_tree<Ingredient&, std::pair<Ingredient&, Quantite&>, std::_Select1st<std::pair<Ingredient&, Quantite&> >, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >::_Rb_tree_impl<std::less<Ingredient&>, false>"
/usr/include/c++/4.1.3/bits/stl_tree.h:437:   instantiated from «std::_Rb_tree<Ingredient&, std::pair<Ingredient&, Quantite&>, std::_Select1st<std::pair<Ingredient&, Quantite&> >, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >"
/usr/include/c++/4.1.3/bits/stl_map.h:134:   instantiated from «std::map<Ingredient&, Quantite&, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >"
recette.cpp:61:   instantiated from here
/usr/include/c++/4.1.3/bits/stl_function.h:226: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h: In instantiation of «std::_Rb_tree<Ingredient&, std::pair<Ingredient&, Quantite&>, std::_Select1st<std::pair<Ingredient&, Quantite&> >, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >":
/usr/include/c++/4.1.3/bits/stl_map.h:134:   instantiated from «std::map<Ingredient&, Quantite&, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >"
recette.cpp:61:   instantiated from here
/usr/include/c++/4.1.3/bits/stl_tree.h:488: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:512: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1211: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1301: erreur: forming pointer to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1311: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1332: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1354: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1365: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1383: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1401: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1419: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1440: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_tree.h:1450: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h: In instantiation of «std::map<Ingredient&, Quantite&, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >":
recette.cpp:61:   instantiated from here
/usr/include/c++/4.1.3/bits/stl_map.h:340: erreur: forming reference to reference type «Quantite&"
/usr/include/c++/4.1.3/bits/stl_map.h:362: erreur: forming reference to reference type «Quantite&"
/usr/include/c++/4.1.3/bits/stl_map.h:371: erreur: forming reference to reference type «Quantite&"
/usr/include/c++/4.1.3/bits/stl_map.h:460: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:533: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:548: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:560: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:575: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:590: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:600: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:610: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:629: erreur: forming reference to reference type «Ingredient&"
/usr/include/c++/4.1.3/bits/stl_map.h:648: erreur: forming reference to reference type «Ingredient&"
recette.cpp:68: erreur: expected constructor, destructor, or type conversion before «&" token
recette.cpp: In member function «void Recette::ajouter_composant(Quantite&, Ingredient&)":
recette.cpp:113: erreur: no match for «operator[]" in «ct[i]"
recette.cpp: In member function «virtual void Recette::afficher(std::ostream&) const":
recette.cpp:130: erreur: no match for «operator<<" in «os << *(std::map<Ingredient&, Quantite&, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >*)((const Recette*)this)->Recette::ContComposant.std::vector<_Tp, _Alloc>::operator[] [with _Tp = std::map<Ingredient&, Quantite&, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >*, _Alloc = std::allocator<std::map<Ingredient&, Quantite&, std::less<Ingredient&>, std::allocator<std::pair<Ingredient&, Quantite&> > >*>](((unsigned int)i))"
/usr/include/c++/4.1.3/bits/ostream.tcc:67: note: candidats sont: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>& (*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:78: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:90: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:241: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:264: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:102: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:125: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:157: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:183: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:215: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:288: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:311: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:361: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:335: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:384: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:407: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.1.3/bits/ostream.tcc:430: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]
recette.h:112: note:                 std::ostream& operator<<(std::ostream&, const Recette&)
ingredient.h:37: note:                 std::ostream& operator<<(std::ostream&, const Ingredient&)
quantite.h:16: note:                 std::ostream& operator<<(std::ostream&, const Quantite&)
/usr/include/c++/4.1.3/bits/stl_pair.h: At global scope:
/usr/include/c++/4.1.3/bits/stl_pair.h: In instantiation of «std::pair<Ingredient&, Quantite&>":
/usr/include/c++/4.1.3/bits/stl_tree.h:135:   instantiated from «std::_Rb_tree_node<std::pair<Ingredient&, Quantite&> >"
/usr/include/c++/4.1.3/bits/stl_tree.h:1264:   instantiated from «void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_erase(std::_Rb_tree_node<_Val>*) [with _Key = Ingredient&, _Val = std::pair<Ingredient&, Quantite&>, _KeyOfValue = std::_Select1st<std::pair<Ingredient&, Quantite&> >, _Compare = std::less<Ingredient&>, _Alloc = std::allocator<std::pair<Ingredient&, Quantite&> >]"
/usr/include/c++/4.1.3/bits/stl_tree.h:578:   instantiated from «std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::~_Rb_tree() [with _Key = Ingredient&, _Val = std::pair<Ingredient&, Quantite&>, _KeyOfValue = std::_Select1st<std::pair<Ingredient&, Quantite&> >, _Compare = std::less<Ingredient&>, _Alloc = std::allocator<std::pair<Ingredient&, Quantite&> >]"
/usr/include/c++/4.1.3/bits/stl_map.h:93:   instantiated from here
/usr/include/c++/4.1.3/bits/stl_pair.h:84: erreur: forming reference to reference type «Quantite&"
make: *** [recette.o] Erreur 1

26/12/2007, 23h14
Pacorabanix

Citation:

Envoyé par ep31

Beh si 8O, c'est le principe même du polymorphisme.

euhhh :oops: oui pardon je vais vite partir en courant par la fenetre... je vous retrouve en bas
27/12/2007, 10h12
ep31

Bon, déjà, il y a un lien de composition entre Recette et Ingredient (via le vector de map<>) donc je ne vois pas pourquoi ta classe Recette hérite de Ingredient.
Mais cela n'explique pas l'erreur.

La ligne :

Code:

os << *ContComposant[i];

me semble étrange,
cela revient à vouloir connaître le contenu du ième élément de ton vector de composants qui se trouve être un élément de type map et donc le ième élément de ton tableau de map.
En écrivant :

Code:

os << ContComposant[i];

n'aurais-tu pas moins d'erreurs ?
27/12/2007, 10h13
ep31

Citation:

Envoyé par Pacorabanix

euhhh :oops: oui pardon je vais vite partir en courant par la fenetre... je vous retrouve en bas

La chute n'a pas été trop douloureuse :lol: ?
27/12/2007, 11h41
falynne

Non, je viens d'essayer, cela ne fonctionne pas.

Au début de mon implémentation, j'avais créé tout simplement une classe Composant et dans ma classe recette j'avais mis std::vector<Composant*> ContComposant;.
Pour l'affichage j'ai donc mis [I]os << *ContComposant; pour avoir le contenu déférencé de mon vector et donc avoir des composants et ma compilation marchait.
Mais depuis que j'ai voulu implémenter mes composants comme étant typedef std::map<Ingredient&,Quantite&> Composant; cela ne fonctionne plus.
27/12/2007, 12h34
ep31

Bizarre, je ne vois pas de problème a priori.
Et en déclarant un :

Code:

std::vector<std::map<Ingredient&,Quantite&>*> ContComposant;

tu as la même erreur ?
27/12/2007, 12h52
falynne

Non, cela ne marche toujours pas:cry:

ok, je crois voir d'où vient l'erreur.
Dans la fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 void Recette::ajouter_composant(Quantite& q,Ingredient& i) { tps=tps + i.temps_de_preparation(); Composant ct; ct[i]=q; ContComposant.push_back(&ct); //ContComposant.push_back(new composant(i,q)); }
Tu déclares un Composant local à ta fonction qui n'est autre qu'un typedef de ta map. Il sera donc perdu à la sortie de ajouter_composant car le push_back de ta référence de ct n'utilisera pas de constructeur de recopie (d'ailleurs c'est une map d'objets abstracts donc...).
Et tu associes à ton Composant une Quantite par :

Code:

ct[i]=q;

alors qu'un Composant est une map d'Ingredient, Quantite.

Cela fait un moment que je n'ai pas touché à C++ mais quelque-chose du style :
Code:

1 2 3 4 5 6 7 8 9 10 void Recette::ajouter_composant(Quantite& q,Ingredient& i) { tps=tps + i.temps_de_preparation(); Composant* ct = new Composant<q,i>; ContComposant.push_back(ct); //ContComposant.push_back(new composant(i,q)); }
devrait mieux marcher (enfin je pense :aie:)

27/12/2007, 14h24
falynne

ça ne marche toujours pas.
Je penses que je vais laisser tomber la map et faire une classe avec des accesseurs tout bête.
Merci pour le temps que tu as passé sur mon problème.