C++ 运算符返回差异

Question

Can anybody explain the difference (if there is any) between the 2 versions of this [] operator? Both version are working fine ...

class Test {

    int arr[100];

    int operator[](int i) {
        return arr[i];
    }

    int & operator[](int i) {
        return arr[i];
    }
};


Test a;
a.arr[5] = 10;

// works for both versions:
int n = a[5];

Answer 1

First, you must make your operators accessible:

class Test {
private: 
    int arr[100];

public:
    int operator[](int i) {
        return arr[i];
    }    
    int& operator[](int i) {
        return arr[i];
    }
};

Now, this won't compile (since arr is private):

Test a;
a.arr[5] = 10;

int operator[](int i) returns by value (an rvalue ), making a[5] = 10; impossible.

int& operator[](int i) returns a reference to the int stored in arr (an lvalue ) which makes a[5] = 10; possible.

But it won't compile since your operators only differ on the return types ( int vs. int& ). Making the one returning by value const solves that issue:

#include <iostream>

class Test {
private:
    int arr[100];

public:
    int operator[](size_t i) const { // note the const
        std::cout << "using operator[]() const\n";
        return arr[i];
    }
    int& operator[](size_t i) {
        std::cout << "using operator[]() mutable\n";
        return arr[i];
    }
};

void test_const(const Test& t) {
    std::cout << t[5] << "\n";
}

int main() {
    Test a;
    a[5] = 10;
    std::cout << a[5] << "\n";
    test_const(a);
}

Output:

using operator[]() mutable
using operator[]() mutable
10
using operator[]() const
10

Answer 2

First, you must make your operators accessible:

class Test {
private: 
    int arr[100];

public:
    int operator[](int i) {
        return arr[i];
    }  // -> Case 1  
    int& operator[](int i) {
        return arr[i];
    } // ->Case 2
};

The difference between above two operators is -

Case 1 -> you can use it only as R value.

Case 2 -> you can use it as "R value" as well as "L value".