How does operator[] work in C++ (Overloading on user defined objecs)?

Question

I understand that developers are able to overload operator[] to either get or set something depending on which side the operator is on. For example you can do obj[2] = test_obj; or test_obj = obj[2]. However I don't understand how the first example works; operator[] returns a reference to something on the heap, so when obj[2] = test_obj; is run, what is happening? If there was something at index 2 already, does it get deleted? does the destructor of the object at 2 get called first? How is this all done since this type of checking isn't done in the operator[]'s method body?

Answer 1

References work very similar to pointers, but references always point to some actual value.

So when operator[] returns a reference, and you assign to that reference, you're assigning directly to the value to which the reference refers. In your example, this would be the object located at index 2. Note that the returned type of Container::operator[] is not a reference to the Container, but rather it is typically a reference to the contained values.

To give a detailed answer it depends on the actual return type of operator[] for the type in question. If the return type is a reference to a primitive type, then it works just like any other reference to a primitive. There are no destructors involved. The assignment takes place directly in the referred value. For example:

int x = 5;
x = 6;

No destructors are called. No operators are called. The value contained by x is replaced by the value on the right hand side of the assignment operator.

Similarly if a reference is involved:

int x = 5;
int &r = x;
r = 6;

No destructors are called. No operators are called. The value to which r points (which in this case is x) is replaced by the value on the right hand side of the assignment operator.

Similarly, if a non-primitive type is involved, then the operator= for the given type will be called.

Foo x;
Foo y;
// Foo::operator=(const Foo &) is called on x with an argument referencing y
x = y;

Neither x nor y's destructor will necessarily be called.

Same thing with a reference:

Foo x, y;
Foo &r = x;
// Foo::operator=(const Foo &) is called on x with an argument referencing y
r = y;

However, operator[] is not required to return a reference; although, that is strongly encouraged.

For non-references or for references to non-primitive types, the operator= of the returned value is invoked, and thus the behavior of the assignment operator is also important.

In the case of operator= the destructor for the left hand side is not invoked, but the assignment operator is itself responsible for any cleanup. This is why assignment operators are often implemented in terms of the copy-swap idiom.

So in the case of std::vector<int>, std::vector<int>::operator[] returns an int &. The assignment happens in place in the location wherever the reference points.

For a std::vector<Foo>, std::vector<Foo>::operator[] returns a Foo & and Foo::operator=(const Foo &) is invoked.

However like I mentioned, a class could return an arbitrary object from operator[] and that object's assignment operator will be called. This can be used to proxy the assignment through another object. A place where you might see this is in a Matrix class that returns a Row object which might in turn implement operator[]. Again this design is not necessarily recommended, but it is not unheard of. In these cases, the return type may not be a reference at all, but an actual value. However, it still works the same way. The Row::operator= or Proxy::operator= is responsible for allocating and clearing any resources necessary. This is why the Rule of Three is so important.

Answer 2

Since operator[] typically returns a reference, it works precisely the same as if a reference was on the left side:

Foo& j;
j = test_obj;

A reference basically works the same as if a regular variable were on the left, since a reference is basically just another way to refer to a variable. So it's essentially the same as:

Foo j;
j = test_obj;

So it's basically just copy assignment, using Foo::operator=(Foo const&) (which always exists in C++). (Even if it's deleted, it still exists -- you will get an error if you try to call it saying that it's deleted, not that no function exists.)