C ++ - surcharge [] opérateur

J'ai une classe de modèle de Tableau:

template <class T=int, int SIZE=10>
class Array {
    T TheArray[SIZE];
public:
    void Initialize() {
        for (int idx=0; idx < SIZE; idx++) {
            TheArray[idx] = T();
        }
    }

    T& operator [](int idx) {
        return TheArray[idx];
    }

    T operator [](int idx) const {
        return TheArray[idx];
    }
}

J'ai quelques questions sur le panneau de [] surcharge (j'ai trouvé cet exemple sur le net).

Je comprends que T& operator [](int idx) de référence de retour à la matrice de la valeur à l'index idx et que T operator [](int idx) const retourne sa valeur.
Cependant, je ne suis pas sûr, auquel cas la référence ou la valeur sera retourné à l'aide de [] opérateur.

Aussi, si je change T operator [](int idx) const -> T operator [](int idx)le compilateur se plaint. Pourquoi est-ce?
Je peux comprendre que le compilateur se plaint parce que seul le type de retour est différent, mais pourquoi il ne se plaint pas quand const est ajouté? Cela veut dire que, non de la classe internes sont modifiés, droit?

J'ai essayé de déboguer ce petit principal de mise en œuvre:

int main() {
    int val;
    Array<> intArray;

    intArray.Initialize();
    val = intArray[1];
    printf("%d", intArray[1]);
    intArray[1] = 5;
}

Et à chaque fois T& operator [](int idx) est appelé. Pourquoi?

Merci d'avance.

source d'informationauteur Mojo28

  1. 12

    La operator[] surcharge seront sélectionnés sur la base de la const-qualification de l'objet que vous appeler.

    Array<> intArray;
intArray[1]; //calls T& operator[]

const Array<> constArray;
constArray[1]; //calls T operator[]

    Si vous supprimez le const de T operator[]vous obtenez une erreur parce que les fonctions de membre ne peut pas avoir la même const-qualification et de paramètres qu'il n'y aurait aucun moyen de choisir entre eux.

  2. 12

    Première chose, [] comme sucre syntaxique pour appeler this->operator[].

    La const version sera appelée si this est un const pointeur, sinon le non-const version sera appelée.

    Sur la route, vous devez utiliser const T& operator [](int idx) const {c'est à dire la const version retour d'un const de référence. Qui va sauver la surcharge de prendre une copie en profondeur.

    Enfin, la const-ness d'une fonction est partie de sa signature. Cela vous permet de surcharge basée sur const-ness. Sinon, vous ne pouvez pas avoir les deux versions de operator[].