Operator [] overloading

Question

I have the following code:

class A
{
    public:
    A() {};
    void operator[](int x)
    {
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    A a;
    a.operator[](0);
    a[0];
}

Both calls work, but I want to know whether there is any difference. Is one more efficient than the other? Do other things happen(besides executing the code in the overloaded operator) in either case?

EDIT: Is there a case why you would want to write a.operator instead of just []. What's the point of overloading if you're not using the short syntax?

Answer 1

Both calls are identical. All the operators can be called with an explicit .operator## syntax, where ## stands for the actual operator symbol.

It is the literal operators like a + b that are just syntactic sugar for a.operator+(b) when it comes to classes. (Though of course for primitive types that is not the case.)

Note that your []-operator is not very typical, since it is usually used to return a reference to something -- but it's up to you how to implement it. You're restricted to one single argument, though, unlike operator().

Answer 2

The explicit operator[] (and any other explicit operator) is used in an inheritence heirarchy, where you are trying to call operator[] on a base class. You can't do that using the normal [], as it would result in a recursive function call. ie; you might use something like this:

struct Base {
    void operator[] (int i) { }
};

struct Derived : public Base {
    void operator[] (int i) 
        { Base::operator[](i); }
};