Discussion :

[Nicoclem]

Bonjour,

Je suis en train de travailler sur des listes chainées en C++ avec template et j'ai besoin de surcharger l'opérateur [] afin de pouvoir accéder à la valeur du i-ème maillon de ma liste si j'écris "Liste[i-1]" par exemple.
Cependant j'obtiens une erreur de segmentation que je ne parviens pas à résoudre lors de l'exécution de mon programme.

Voici mon code :

Liste.h :

Code :

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

1
2
3
4
 
//Début...
T& operator[](int) const;
//Fin...

Liste.inl :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
//Début...
template<class T>
T& Liste<T>::operator[](int i) const
{
        //Simple essai avec i = 0
        //Lignes qui posent problèmes 
        (*this)[i] = m_tete->m_data;
        return (*this)[i];
}
//Fin...

et enfin main.cc :

Code :

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

1
2
3
4
 
//Début...
cout << "Liste[0] : " << Liste[0] << endl; //Problème : erreur de segmentation
//Fin...

Toutes vos suggestions sont les bienvenues ! Merci d'avance

[Invité(e)]

Bonjour,

Il me semble louche d'avoir dans la définition de l'opérateur [] un appel a ce même operateur ?

j'aurais plutôt écrit une chose du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
//En supposant qu'on accède au suivant par ->pNext,
 
template<class T>
T& Liste<T>::operator[](int i) const
{
   T* pCurr = &m_tete;
   while(pCurr && i--){
      pCurr = pCurr->pNext;
   }
   return * pCurr;
}
//Fin...

[Médinoc]

De plus, pour une liste, ça me paraît louche d'avoir l'opérateur const qui retourne une référence non-const...
Tu dois faire deux opérateurs:

Code C :

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
template<class T>
T const & Liste<T>::operator[](int i) const
{
   T const * pCurr = &m_tete;
   while(pCurr && i--){
      pCurr = pCurr->pNext;
   }
   return * pCurr;
}
 
template<class T>
T & Liste<T>::operator[](int i)
{
   T* pCurr = &m_tete;
   while(pCurr && i--){
      pCurr = pCurr->pNext;
   }
   return * pCurr;
}

Ou réutiliser avec un const_cast bien placé:

Code C :

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
//La version const reste const-correcte jusqu'au bout
//et n'utilise aucun const_cast.
template<class T>
T const & Liste<T>::operator[](int i) const
{
   T const * pCurr = &m_tete;
   while(pCurr && i--){
      pCurr = pCurr->pNext;
   }
   return * pCurr;
}
 
//La version non-const appelle la version const
//et const_caste la référence retournée.
template<class T>
T & Liste<T>::operator[](int i)
{
   //NOTE: On const_caste toujours le pointeur retourné,
   // et jamais this!
   Liste< T > const * thisC = this;
   T const & ret = (*thisC)[i];
   return const_cast< T & >(ret);
}

[Nicoclem]

Hmmm oui pourquoi pas. J'avais pas envisagé cette solution, je vais essayer. Merci !