C++ selectively overloading [ ]?

Question

Given:

class example
{
    public:
        std::vector<std::vector<int>> a;
        int b;
}

func()
{
    example e;
    ... // populate e

I could then use examples members like so.

    int n = e.b;
    int n2 = e.a[2][3];

However, could I alternatively override the [ ] operator such that.

    int n = e.b;
    int n2 = e[2][3];
}

?

edit: Sorry, the example is now fixed.

Where is your need for overloading? I've dont see any `[]` needing. — Hauleth, Mar 29 '12 at 20:54
I am not sure what the down votes are for. Seems like a valid question. — Martin York, Mar 29 '12 at 21:05
@Loki : The downvotes were probably pre-edit, when the question had no relation to `operator[]`. — ildjarn, Mar 29 '12 at 21:06
-1 for drastically changing the question. @LokiAstari see the revision history. — Luchian Grigore, Mar 29 '12 at 21:06
Sorry, I suck reguarding the edit, especially to the person who had just answered, this is the question I meant to ask though :¬P and it has a great answer by Christian Rau. — alan2here, Mar 29 '12 at 21:14

score 4 · Accepted Answer · answered Mar 29 '12 at 21:01

What you could do is overload the access operator and delegate it to the vector:

class example
{
    public:
        std::vector<std::vector<int>> a;
        int b;

        const std::vector<int>& operator[](std::size_t i) const
        {
            return a[i];
        }
        std::vector<int>& operator[](std::size_t i)
        {
            return a[i];
        }
};

The first [] will then return a reference to a's respective element, on which the second [] will be used.

score 2 · Answer 2 · answered Mar 29 '12 at 21:04

One naive solution would be to define your own operator[]:

class example
{
    std::vector<std::vector<int>> v;
public:
    std::vector<int> const & operator[](std::size_t i) const { return v[i]; }
    std::vector<int>       & operator[](std::size_t i)       { return v[i]; }

    // ...
};

Now if you have example e;, then e[1] is a vector of ints, etc.

It looks like you want to write some matrix class, though. For that, it's more efficient to have just a single vector and access it in strides:

class Matrix
{
    std::size_t cols;
    std::size_t rows;
    std::vector<int> v;

public:
    explicit Matrix(std::size_t r, std::size_t c) : cols(c), rows(r), v(r*c) { }

    int operator()(std::size_t i, std::size_t j) const { return v[i * cols + j]; }
    int & operator()(std::size_t i, std::size_t j) { return v[i * cols + j]; }
};

Now you can say: Matrix m(4, 7); m(1, 3) = 8;. You have to use the round-bracket operator for that, since the square-bracket operator must always take exactly one argument and thus isn't suitable here.

C++ selectively overloading [ ]?

2 Answers2