Erreur de segmentation surcharge opérateur []

Version imprimable

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:

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

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:

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

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:

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

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:

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:

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);
}

17/04/2008, 18h05
Nicoclem

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