了解重载的operator []示例

Question

I am confused with a question that I saw in a c++ test. The code is here:

#include <iostream>
using namespace std;

class Int {
public:
    int v;
    Int(int a) { v = a; }
    Int &operator[](int x) {
        v+=x;
        return *this;
    }
};
ostream &operator<< (ostream &o, Int &a) {
    return o << a.v;
}

int main() {
    Int i = 2;
    cout << i[0] << i[2]; //why does it print 44 ?
    return 0;
}

I was kinda sure that this would print 24 but instead it prints 44 . I would really like someone to clarify this. Is it a cumulative evaluation? Also is the << binary infix ?

Thanks in advance

EDIT : in case of not well defined operator overload, could someone give a better implementation of the overloaded operators here so it would print 24 ?

Answer 1

This program has indeterminate behavior: the compiler is not required to evaluate i[0] and i[2] in a left-to-right order (the C++ language gives this freedom to compilers in order to allow for optimizations).

For instance, Clang does it in this instance , while GCC does not .

The order of evaluation is unspecified, so you cannot expect a consistent output, not even when running your program repeatedly on a specific machine.

If you wanted to get consistent output, you could rephrase the above as follows (or in some equivalent way):

cout << i[0];
cout << i[2];

As you can see, GCC no longer outputs 44 in this case.

EDIT:

If, for whatever reason, you really really want the expression cout << i[0] << i[2] to print 24 , you will have to modify the definition of the overloaded operators ( operator [] and operator << ) significantly, because the language intentionally makes it impossible to tell which subexpression ( i[0] or [i2] ) gets evaluated first.

The only guarantee you get here is that the result of evaluating i[0] is going to be inserted into cout before the result of evaluating i[2] , so your best bet is probably to let operator << perform the modification of Int's data member v , rather than operator [] .

However, the delta that should be applied to v is passed as an argument to operator [] , and you need some way of forwarding it to operator << together with the original Int object. One possibility is to let operator [] return a data structure that contains the delta as well as a reference to the original object:

class Int;

struct Decorator {
    Decorator(Int& i, int v) : i{i}, v{v} { }
    Int& i;
    int v;
};

class Int {
public:
    int v;
    Int(int a) { v = a; }
    Decorator operator[](int x) {
        return {*this, x}; // This is C++11, equivalent to Decorator(*this, x)
    }
};

Now you just need to rewrite operator << so that it accepts a Decorator object, modifies the referenced Int object by applying the stored delta to the v data member, then prints its value:

ostream &operator<< (ostream &o, Decorator const& d) {
    d.i.v += d.v;
    o << d.i.v;
    return o;
}

Here is a live example .

Disclaimer : As others have mentioned, keep in mind that operator [] and operator << are typically non-mutating operations (more precisely, they do not mutate the state of the object which is indexed and stream-inserted, respectively), so you are highly discouraged from writing code like this unless you're just trying to solve some C++ trivia.

Answer 2

To explain what's going on here, let's make things much simpler: cout<<2*2+1*1; . What happens first, 2*2 or 1*1? One possible answer is 2*2 should happen first, since it's the leftmost thing. But the C++ standard says: who cares?! After all, the result is 5 either way. But sometimes it matters. For instance, if f and g are two functions, and we do f()+g() , then there is no guarantee which gets called first. If f prints a message, but g exits the program, then the message may never be printed. In your case, i[2] got called before i[0] , because C++ thinks it doesn't matter. You have two choices:

One option is to change your code so it doesn't matter. Rewrite your [] operator so that it doesn't change the Int , and returns a fresh Int instead. This is probably a good idea anyway, since that will make it consistent with 99% of all the other [] operators on the planet. It also requires less code:

Int &operator[](int x) { return this->v + x;} .

Your other option is to keep your [] the same, and split your printing into two statements:

cout<<i[0]; cout<<i[2];

Some languages actually do guarantee that in 2*2+1*1 , the 2*2 is done first. But not C++.

Edit: I was not as clear as I hoped. Let's try more slowly. There are two ways for C++ to evaluate 2*2+1*1 .

Method 1: 2*2+1*1 ---> 4+1*1 ---> 4+1 --->5 .

Method 2: 2*2+1*1 ---> 2*2+1 ---> 4+1 --->5 .

In both cases we get the same answer.

Let's try this again with a different expression: i[0]+i[2] .

Method 1: i[0]+i[2] ---> 2+i[2] ---> 2+4 ---> 6 .

Method 2: i[0]+i[2] ---> i[0]+4 ---> 4+4 ---> 8 .

We got a different answer, because the [] has side effects, so it matters whether we do i[0] or i[2] first. According to C++, these are both valid answers. Now, we are ready to attack your original problem. As you will soon see, it has almost nothing to do with the << operator.

How does C++ deal with cout << i[0] << i[2] ? As before, there are two choices.

Method 1: cout << i[0] << i[2] ---> cout << 2 << i[2] ---> cout << 2 << 4 .

Method 2: cout << i[0] << i[2] ---> cout << i[0] << 4 ---> cout << 4 << 4 .

The first method will print 24 like you expected. But according to C++, method 2 is equally good, and it will print 44 like you saw. Notice that the trouble happens before the << gets called. There is no way to overload << to prevent this, because by the time << is running, the "damage" has already been done.