Operator [] overloading

Asked by At

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?

5 Answers

4
Seb Holzapfel On Best Solutions

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); }
};
5
Kerrek SB On

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().

2
foxy On

Other than having to type another 11 characters, there is no functional difference between the two.

1
sharptooth On

They are completely equivalent - just in once case C++ adds syntactic sugar that makes your code prettier. You can call all overloaded operators explicitly - the effect will be the same as when they are called implicitly and the compiler redirects calls to them.

1
iammilind On

No there is no difference between both versions from performance point of view. a[0] is more readable.

Also, the operator [] is typically defined as,

Type& operator[](const int x)
{
  return v[x];  // Type 'v' is member variable which you are accessing for array
}