C++: opérateur d'indexation surchargé

Question

Je suis en train d'implémenter un vecteur, donc je voulais qu'il se comporte comme un tableau. C'est la raison pour laquelle j'ai essayé d'implémenter l'opérateur d'indexation, mais je n'ai pas réussi le bon comportement.

La mise en œuvre était quelque chose comme ceci:

template <typename value_type> 
class Vector{ 
    private: 
    value_type ** vector ; 
    long size ; 
    long usedSize ; 

    public: 
    /.../ 
    value_type & operator [] (long) ; // For writing. 
    const value_type & operator [] (long) const ; // For reading. 
    /.../ 
} 

template<typename value_type> 
value_type & Vector<value_type>::operator[] (long index) { 
    if (index < 0 || index > usedSize) 
     return out_of_range() ; 
    else { 
     vector[index] = new value_type() ; 
     usedSize++ ; 
     return *(vector[index]) ; 
    } 
} 

template<typename value_type> 
const value_type & Vector<value_type>::operator[] (long index) const { 
    if (index < 0 || index > usedSize) 
     return out_of_range() ; 
    else { return (*vector[index]) ; } 
} 

Puis-je tester le comportement de l'objet avec ceci:

int main (void) { 
    Vector<int> * v = new Vector (10) ; // Creates a vector of 10 elements. 
    (*v)[0] = 3 ; 
    int a = (*v)[0] ; 
    cout << "a = " << a << endl ; 
} 

Et je reçois ce de l'exécution:

$> a = 0 

Certains threads recommandent d'utiliser une classe de gestionnaire surchargeant l'opérateur d'affectation, je me demande si il y a de toute façon à éviter l'utilisation d'un objet gestionnaire pour faire la tâche.

Merci d'avance.

Gonzalo d'Argentine.

Answer 1

Vous avez tort en supposant que la ligne

Cout < < "a =" < < (* v) [0] < < endl;

Le

const value_type & Vector :: operator [] (à long index) const

seront utilisés.

En fait les deux fois

value_type & Vector :: operator []

est utilisé pour vous "remplacer" la valeur précédente avec une nouvelle (et une fuite de mémoire en même temps)

ci-dessous devrait aider

value_type & Vector<value_type>::operator[] (long index) { 
    if (index < 0 || index > usedSize) 
     ///out of bounds handling 
    else { 
     if(vector[index]== 0) 
     { 
      vector[index] = new value_type() ; 
      usedSize++ ; 
     } 
     return *(vector[index]) ; 
    } 
}