Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

répétition d'opérateurs surchargés et plantage


Sujet :

Langage C++

  1. #1
    Membre du Club
    répétition d'opérateurs surchargés et plantage
    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

  2. #2
    Expert confirmé
    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.

###raw>template_hook.ano_emploi###