c++ () operator problem

Question

I've got another problem when trying to overload the () operator for array access:

const OctTreeNode*& operator()(const int i, const int j, const int k) const{ 
 return m_cells[k*m_resSqr+j*m_res+i];
}

OctTreeNode*& operator()(const int i, const int j, const int k){ 
 return m_cells[k*m_resSqr+j*m_res+i];  
}

vector<OctTreeNode*> m_cells;

I get a

C2440 'return': cannot convert from 'OctTreeNode *const' to 'const OctTreeNode *&'

what's the deal? i'm declaring it exactly as in another class. the only difference is that the other class is generic, and there i'm using T& instead of OctreeNode*&

Answer 1

The first operator should return const

const OctTreeNode * const & operator()(const int i, const int j, const int k) const{ 
        return m_cells[k*m_resSqr+j*m_res+i];
}

... or the const before the *, I never seem to remember -_-

First const tells us that we can't modify OctTreeNode, second one tells us that we can't modify the pointer to it (set it to NULL for example) while the third one tells us that the method doesn't change the object.

To be honest I'm unsure wether the first one is needed, as the only thing that we need to grant const correctness to the method, is to grant that nobody will change references to those pointers.

Answer 2

There is very little point in passing by const value, as you're doing with i, j, k.

Answer 3

The constant operator is incorrect, you are returning a non-constant reference to a pointer to a constant OctTreeNode.

That is, if you declare a pointer as

const int *a;

a is not constant, what a points to is constant. So when you declare the return type as

const OctTreeNode*&

the OctTreeNode is constant, but the pointer is not. This is an error because your member function is const, so the std::vector is const, and so the pointer that it returns is also constant - ultimately you try to return a const-pointer as a non-const pointer.

To correct this just remove the reference

const OctTreeNode* operator()

because there's not much point returning a reference to a constant pointer, you can't modify the pointer and the reference will (probably) have the same size as the pointer anyway.

Answer 4

Kornel is correct. To clarify should the const be before or after the *, after. The two types const OctTreeNode * const & and OctTreeNode const * const & are identical, both are easily understood when read from right to left.

const OctTreeNode * const & is a reference to a const point to an OctTreeNode that is const.

OctTreeNode const * const & is a reference to a const pointer to a const OctTreeNode.

Note that these types are different from the invalid type const OctTreeNode const * &. This would be a reference to a pointer to a const OctTreeNode that is const.

Notice the last part of the sentence a const OctTreeNode that is const. One of the const is redundant, and this type, had it been legal, would be equivalent to const const OctTreeNode * &