Discussion :

[falynne]

Bonjour et Joyeux Noel en retard!!

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.

[ep31]

Qu'est-ce qui ne marche pas exactement ?
Un problème de compilation, de modélisation, d'exécution ?

[Pacorabanix]

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 ?

[Pacorabanix]

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

[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é?

[falynne]

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.

[Pacorabanix]

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.

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 :

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

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.

[ep31]

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 , c'est le principe même du polymorphisme.

[ep31]

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 ?

[falynne]

Recette.h

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

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

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

[Pacorabanix]

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

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

[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 :

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

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 :

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

os << ContComposant[i];

n'aurais-tu pas moins d'erreurs ?

[ep31]

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

La chute n'a pas été trop douloureuse ?

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

[ep31]

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

Code :

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

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

tu as la même erreur ?

[falynne]

Non, cela ne marche toujours pas

[ep31]

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

Code :

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

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 :

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

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 :

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

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 )

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