Discussion :

[inge3000]

Bonjour,

J'ai écrit une classe qui permet de manipuler des Constructions, qui sont en fait un groupe de Briques.

J'essaye de surcharger certains opérateurs pour empiler des constructions.

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
class Construction
{
 
public:
vector<vector<vector<Brique>>> contenu ;
Construction(Brique b) : contenu(1, vector<vector<Brique>>(1, vector<Brique>(1,b))){}
  Construction & operator ^= (Construction const &b);
    Construction&  operator-=(Construction const& b)  ;
    Construction&  operator+=(Construction const& b)  ;
 
ostream& afficher(ostream& sortie) const 
{
	if (contenu.empty())
	{
		return sortie ; 
	}
	else 
	{
        for (size_t i = contenu.size(); i--; ) 
        {
			sortie << "couche " << i << " :\n"  ; 				
			for (size_t k = 0 ; k< contenu[i].size() ; k++)
			{
			    sortie << "ligne " << k << " :\n"  ; 				
				for (size_t j = 0 ; j< contenu[i][k].size() ; j++)
				{
					sortie << contenu[i][k][j] ;		
				}
				sortie << "\n" ; 
			}
 
    	}
	    return sortie ;
	}
}
 
 
 
};
 
 
  Construction & Construction::operator^= (Construction const &b)
 {
     for(size_t i(0); i< b.contenu.size();i++)
	  {
	      contenu.push_back(b.contenu[i]);
	  }
	return (*this);
 
 }
  Construction&  Construction::operator-=(Construction const& b)  
 {
          if(b.contenu.size() >= contenu.size())
          {
              for(size_t i(0); i< contenu.size();i++)
              {
                for(size_t j(0); j< b.contenu[i].size();j++)
                {
                    contenu[i].push_back(b.contenu[i][j]);
 
                }
              }
          }
          	return (*this);
 
 }
 
 
Construction&  Construction::operator+= (Construction const& b)
  {
    int flag = 1;
 
    if (b.contenu.size () < contenu.size ())
	{
	    flag = 0;
    }
    else
    {
 
	    for (size_t i (0); i < contenu.size (); i++)
    	{
        	if (b.contenu[i].size () < contenu[i].size ())
        	{
        	    flag = 0; 
        	    break ; 
        	}
 
    	}
    	if(flag == 1)
    	{
 
    	    for (size_t i (0); i < contenu.size (); i++)
        	{
                	for (size_t j (0);j <contenu[i].size (); j++)
                	{
 
                    	for (size_t k (0); k < b.contenu[i][j].size (); k++)
                    	{
        	                contenu[i][j].push_back (b.contenu[i][j][k]);
                    	}
 
 
                	}
        	}
        }
    }
 
    return (*this);
 
}
 
 
 
 
 
 ostream& operator<<(ostream& sortie, Construction const& b)  
 {
	 return b.afficher(sortie) ;	 
 }

Dans le main, je peux construire une petite maison.. Mon problème est que je n'arrive pas à enchainer plusieurs fois le même opérateur += pour ajouter une brique à une maison. Je suis obligé de le faire étape par étape.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
  Brique toitM(" pleine ", "rouge");
  Brique mur  (" pleine ", "blanc");
 
  // on construit les murs
  Construction maisonblanche(mur );
  Construction briqueblanche(mur );
  Construction briquerouge(toitM );
 
  maisonblanche += briqueblanche;

Cet extrait tourne bien dans le main, mais je ne peux pas faire quelquechose comme maisonblanche += briqueblanche += briqueblanche += briqueblanche;.
Le programme tourne indéfiniment et finit par planter. Je n'ai pas de warning du compilateur.. Auriez-vous une idée de ce qui manque ?

Merci bien

[dalfab]

Bonjour,

Tu n'indiques pas ce que fait l'operator+= entre 2 briques donc difficile de dire ce que fait maisonblanche += briqueblanche += briqueblanche += briqueblanche, est-ce que tu ne cherches pas plutôt à faire ((maisonblanche += briqueblanche) += briqueblanche) += briqueblanche qui lui n'utilisera que l'operator+= entre une maison et une brique.

[Bousk]

En utilisant une fonction membre spécifique ou l'opérateur << et non += le problème devrait disparaître.
Probablement que += se lit de droite à gauche et non gauche à droite comme tu t'y attendais.