Question

is there any reason why

foo = (bar->at(x))->at(y);

works but

foo = bar[x][y];

does not work, where bar is a vector of vectors (using the c++ stl)

the declaration is:

std::vector< std::vector < Object * > * >

Answer 1

Is it a vector of vectors or a vector of pointers to vectors? Your code should work as advertised:

typedef std::vector<int> vec_int;
typedef std::vector<vec_int> multi_int;

multi_int m(10, vec_int(10));

m.at(2).at(2) = /* ... */;
m[2][1] = /* ... */;

But your code appears to have:

typedef std::vector<vec_int*> multi_int; // pointer!
multi_int* m; // more pointer!

If you have pointers, you’ll need to dereference them first to use operator[]:

(*(*m)[2])[2] = /* ... */;

That that can be ugly. Maybe use references temporarily:

multi_int& mr = m;
(*mr[2])[2] = /* ... */;

Though that still has some ugly. Maybe free-functions are helpful:

template <typename T>
typename T::value_type& access_ptr(T* pContainer,
                                    unsigned pInner, unsigned pOuter)
{
    return (*(*pContainer)[pInner])[pOuter]);
}

access_ptr(m, 2, 2) = /* ... */

Most preferable is to be rid of the pointers, though. Pointers can leak and have all sorts of problems, like leaking when exceptions are thrown. If you must use pointers, use a pointer container from boost for the inner vector, and store the actual object in a smart pointer.

Also, your title is a bit misleading. The difference between at and operator[] is that at does range checks. Otherwise, they are the same.