Discussion :

[Treuze]

Le probleme se trouve cette fois dans liste :: operator+(const maillon<T>)
g++ me dit

liste.cc: In member function ‘liste<T>& liste<T>::operator+(const maillon<T>&) [with T = int]’:
Client.cc:49: instantiated from here
liste.cc:206: erreur: passing ‘const maillon<int>’ as ‘this’ argument of ‘T& maillon<T>::valeur() [with T = int]’ discards qualifiers

Voici le code :

Le liste.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
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
 
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream.h>
 
// Classe T
class T {
};
 
// Classe maillon
template <class T> class maillon {
 
 
      // Champs prives
      private:
        T data ;
        maillon<T> *suivant ;
 
      // Forme canonique de Coplien
      public:
        maillon();
        maillon(const maillon<T>&) ;
        maillon(const T);
         ~maillon() ;
        maillon<T>& operator=(const maillon<T>&) ;
         maillon<T>& operator=(const T);
 
      // Autres methodes et operateurs
         maillon<T>* gonext();
         T& valeur();
         void affichemaillon();
};
 
// Classe liste
template <class T> class liste {
      // Champs prives
      private:
        maillon<T>* tete;
         maillon<T>* fin ;
 
      // Forme canonique de Coplien
      public:
        liste() ;
        liste(const liste<T>&) ;
         ~liste() ;
 
      // Ajout de maillons
         liste<T>& operator+ (const T) ; //ajoute en fin de liste un elemnt
         liste<T>& operator+ (const maillon<T>&) ;  //ajoute en fin de liste
 
 
      // Entrees-sorties
         void affiche () const ; // Fonction constante qui ne peut pas modifier les champs de la classe
 
      // Autres methodes et operateurs
          int longueur();
};

mon liste.cc :

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
 
 
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
 
#include "liste.h"
 
template <class T>
maillon<T> :: maillon ()
{
  data = 0;
  suivant = NULL;
}
 
template <class T>
maillon<T> :: maillon (const maillon<T>& m)
{
  data = m.data;
  suivant = NULL;
}
 
template <class T>
maillon<T> :: maillon (const T valeur)
{
 data = valeur;
 suivant = NULL;
}
 
template <class T>
maillon<T>* maillon<T> :: gonext()
{
 
   return suivant;
 
}
 
template <class T>
T& maillon<T> :: valeur()
{
  return data;
}
 
template <class T>
liste<T> :: liste()
{
  tete = NULL ;
  fin = NULL ;
}
 
template <class T>
liste<T>& liste<T> :: operator+ (const T valeur)
{ 
  maillon<T>* parcours;
  maillon<T>* tmp;
 
  if (longueur() == 0)
    {
      tete = new maillon<T> (valeur);
      parcours = tete;
    }
  else
    {
      parcours = tete;
 
      while ((*parcours).gonext() != NULL)
	parcours = (*parcours).gonext();
 
      tmp = new maillon<T> (valeur);
      (*parcours).modifpointeur(*tmp);
    }
    fin= parcours;
 
  return *this;
}
 
 
template <class T>
liste<T>& liste<T> :: operator+ (const maillon<T>& m)
{
      *this.operator+(m.valeur()); 
     return *this;
}

et mon client.cc :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include "liste.h"
#include "liste.cc"
 
int main(int argc, char **argv)
{
liste<int> l1;
   l1 + m1 ;  // m1 et un maillon deja cree et teste
}

Les methodes maillons marchent , la fonction liste :: operator+(T) marche

Alors je ne comprends pas :
la fonction T maillon :: valeur() renvoie une valeur de type T et si je la passe en argument ds ma fonction operator+(T) ca devrait marcher non ???

Merci

[TanEk]

Ta méthode maillon::valeur n'est pas une méthode constante (const est une "qualifier" comme dit dans le message d'erreur :

liste.cc:206: erreur: passing ‘const maillon<int>’ as ‘this’ argument of ‘T& maillon<T>::valeur() [with T = int]’ discards qualifiers

Il suffit donc d'écrire la méthode constante :

Code :

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

1
2
3
 
T& valeur();
T& valeur() const; // méthode constante

Je n'ai pas testé ma solution mais je pense que c'est juste.

[Treuze]

En fait c etait pas ca , je renvoyais un type &T dans ma fonciton valeur . j ai enleve cette derniere et plus d erreur de compilation

Par contre , ca ne m ajoute aps de nouveau maillon...

[Matthieu Brucher]

Si tu déclares ta méthode const et que tu n'as pas d'erreur, tu as un gros souci, tu modifies quand même ta liste !
Tu dois tout de même renvoyer quelque chose de ta fonction valeur, sans quoi tu n'ajouteras rien dans ta liste. tu dois avoir 2 fonction valeur(), au pire, une const qui renvoie un const et une autre normale.

[Treuze]

Bah alors lacomprends pas .. c quoi al difference entre ces deux fonctions ?

[Matthieu Brucher]

La décoration et le fait que l'une dise qu'elle laisse l'objet constant et pas l'autre. Tu peux en avoir besoin si tu veux parfois modifier la valeur dans ta liste - auquel cas il te faut la version non constante - et si tu veux récupérer la valeur du maillon pour l'insérer dans une autre liste - là, c'est la version constante -

[Treuze]

Ok mais pourquoi est ce que ma liste serai modifie alros que je ne la touche aps ds le programme ?

[Matthieu Brucher]

Le compilateur ne peut pas savoir si tu vas effectivement modifier ou pas ton code, pour ça, il faut l'aider avec des const. Et c'est aussi et surtout un garde-fou pour toi