Overloading [] operator

[C_ntua]

I was wondering how to overload the [] operator. A common example is this:

class myClass
{
   int data[];
   int maxSize;
   ....
   public:
     ...
      int &operator[] (int index) {
         if (index < maxSize)
            return data[index];
         else
           ...
        }
}

Why is the & for reference used? I don't fully understand the reason. What would be the difference by simply returning int?

[laserlight]

Consider this expression: xyz[0] = 1;

If operator[] returned by value, then the element of xyz at index 0 would not be changed to 1.

Also, read this FAQ on const overloading as it applies to overloading operator[].

[master5001]

Just remember what a reference means. It means you are returning that specific variable instead of a copy of what that array element contains.

You can do some other nifty stuff with that operator too.

Example:

myclass &operator[](const std::string &name);

[Elysia]

std::map<int, int> mymap;
mymap[5] = 10; // What would happen here if mymap returns, say, char*?

In the code above, the compiler will assign 10 to whatever is returned from mymap[5].
So if mymap[5] returned char* instead of int&, what would happen? Compile error, and not something you'd expect!
And if it merely returned int, the you would assign to a temporary!
In other words, you don't make any change in the map at all.

class myClass
{
    int data[];
    int maxSize;
    ...
public:
    ...
    int& operator[] (int index)
    {
        if (index < maxSize)
            return data[index];
        else
            ...
    }
};

And please, write the class the right way

[C_ntua]

Thanks for the replies. The right way you say? Are you referring to the public word, which shouldn't be in the same level with class?
If that is the case, I would like to ask. You should write classes like:

class myClass
{
   private:
        int a;
        int b;
    public:
        int c;
        int d;
};

If you don't use private, then int a, int b should be alligned with public or int c, int d?

[Elysia]

I changed public to the same level as the braces.
I changed int &operator to int& operator.
I also changed the indentation to be consistent (4 spaces everywhere; can't use tabs in the browser), instead of some spaces here and there.
Also moved the opening brace down one line.

Unfortunately, it's all about style
I love this style, but others might not.
But I insist that * and & binds to the type in C++ and not the name.

[C_ntua]

Oh, you changed it that is what got me confused, because I just thought you copy/pasted it. Lol. Yeah, mine was horrible and I have complaint about these things to a lot of people. Most of the codes I see have public in a different level from class, but again that is just style. I prefer the way you write it though, alligning it with class.

As for * and &. Well, I agree that it makes more sense to think that when you declare a variable you have "type" "name". So the type should be like int*. If you write "type" "*name" then the type of the variable is a int*, even though you write int. And you mix information (that this is a pointer) with the name.

What I don't like is having it in the middle. That is bad for me. Except for function declaration which is another story.

On the other hand, it is more readable for me if you have it in front of the name. It looks "worse", but personally most of the times I don't care about whether the variable is int or long. That won't change the logic of the program most of the times. But if it is a pointer or a variable is important, it changes the logic. So I will most likely read only the name of the variable and not the type. At least at first glance. So having the * in front of the name helps me get that information right away.
And... this has nothing to do with the subject which I created...

[CornedBee]

But I insist that * and & binds to the type in C++ and not the name.

Wouldn't it be great if it did? Unfortunately, syntactically it doesn't, and putting the * and & to the name is a good way of reminding yourself of that little wart of the language.
I still put it next to the core type in return types, though.

[Elysia]

Wouldn't it be great if it did? Unfortunately, syntactically it doesn't, and putting the * and & to the name is a good way of reminding yourself of that little wart of the language.
I still put it next to the core type in return types, though.

Yes, it would certainly be great, and dang it, how I wished they would allow it to actually bind to the type syntactically. But unfortunately it's a relic from C, not to mention how many people it would upset and how code it would break.
Sometimes I wish C++ was more separated and strict from C and getting rid of old stuff and bad practices.
Maybe someone will one day make C+++