J'ai un sujet sur lequel je suis confus et sur lequel il me faut approfondir. Il surcharge l'opérateur avec une version const et une version non const.
// non-const
double &operator[](int idx) {
if (idx < length && idx >= 0) {
return data[idx];
}
throw BoundsError();
}
Je comprends que cette fonction, partie d’une classe, prend un index et vérifie que sa logique retourne l’index des données du tableau dans la classe. Il y a aussi une fonction avec le même corps mais avec l'appel de fonction comme
const double &operator[](int idx) const
Pourquoi avons-nous besoin de deux versions?
Cet exemple de question peut également vous aider à élaborer. Quelle version est utilisée dans chaque instance ci-dessous?
Array a(3);
a[0] = 2.0;
a[1] = 3.3;
a[2] = a[0] + a[1];
Mon hypothèse selon laquelle la version const n'est appelée que sur a[2]
car nous ne voulons pas risquer de modifier a[0]
ou a[1]
.
Merci pour toute aide.
Lorsque les deux versions sont disponibles, la logique est assez simple: la version const
est appelée pour les objets const
, la version non -const
est appelée pour les objets non -const
. C'est tout.
Dans votre exemple de code, a
est un objet non -const
, ce qui signifie que la version non -const
est appelée dans tous les cas. La version const
est jamais appelée dans votre exemple.
L'intérêt d'avoir deux versions est d'implémenter un accès "lecture/écriture" pour les objets non -const
et uniquement un accès "en lecture" pour les objets const
. Pour les objets const
, la version const
de operator []
est appelée, ce qui renvoie une référence const double &
. Vous pouvez lire des données à travers cette référence const, mais vous ne pouvez pas écrire à travers.
Pour fournir un exemple de code pour compléter la réponse ci-dessus:
Array a(3);
a[0] = 2.0; //non-const version called on non-const 'a' object
const Array b(3);
double var = b[1]; //const version called on const 'b' object
const Array c(3);
c[0] = 2.0; //compile error, cannot modify const object