[RESOLVED] const operator[]

[r.stiltskin]

In this template

template <class T>
class dynamic_2d_array
{
public:
  dynamic_2d_array(int row, int col) : m_row(row),
                                       m_col(col),
                                       m_data((row != 0 && col != 0) ? new T[row * col] : NULL){}

  dynamic_2d_array(const dynamic_2d_array& src) : m_row(src.m_row),
                                                  m_col(src.m_col),
                                                  m_data((src.m_row != 0 && src.m_col != 0) ? new T[src.m_row * src.m_col] : NULL)
  {
    for(int r = 0;r < m_row; ++r)
      for(int c = 0; c < m_col; ++c)
        (*this)[r][c] = src[r][c];
  }

  ~dynamic_2d_array()
  {
    if(m_data)
      delete []m_data;
  }
  
  inline T* operator[](int i) { return (m_data + (m_col * i)); }

  inline T const*const operator[](int i) const {return (m_data + (m_col * i)); }


private:
  dynamic_2d_array& operator=(const dynamic_2d_array&);
  const int m_row;
  const int m_col;
  T* m_data; 
};

which I found here: http://www.codeguru.com/forum/showthread.php?t=297838
is the const operator[] provided specifically to enable a calling function to assign the return value to a const pointer, e.g.

T const * const tp = arr2d[n];

Or does it serve some other purpose?

[Paul McKenzie]

Or does it serve some other purpose?

The const overload allows you to use operator [] on the right side of an equal sign for const objects.

Comment out the const overload. Once you do that, try to do this:

void foo(const dynamic_2d_array<int>& myArray)
{
    const int *p = myArray[0];
}

You will get a compiler error that you are attempting to call a non-const function (operator []) on a const object.

Regards,

Paul McKenzie

[r.stiltskin]

That's what I thought (see bottom of my post). I was just wondering if there was some other obscure reason.

Thanks Paul.

[alanjhd08]

r-stiltskin,

As far as I can see, there's no need for a const [] operator if all you want do is:
T const * const tp = arr2d[n];

However, there are 3 consts in the operator overload:

    inline T const*const operator[](int i) const {return (m_data + (m_col * i)); }

As far as I can see the 2nd one (in bold) has no effect, since it's on the returned type.

Paul's example requires the 3rd one, since the 2dArray is const.

Which leaves the 1st one. Is that the one you're asking about?

[D_Drmmr]

As far as I can see, there's no need for a const [] operator if all you want do is:
T const * const tp = arr2d[n];

As Paul explained, there is a need if arr2d is const.
In general, the 'need' for the const overload is for the class to be const-correct. If it isn't the code is not reusable, so you should strive to write const-correct code.

However, there are 3 consts in the operator overload:

    inline T const*const operator[](int i) const {return (m_data + (m_col * i)); }

As far as I can see the 2nd one (in bold) has no effect, since it's on the returned type.

It has the 'effect' that you cannot write code like

dynamic_2d_array<int> a;
// ...
assert(++a[0] == a[1]);

Note that, since the pointer is returned by value, any operation on the returned pointer has no effect on the underlying dynamic_2d_array. So, it's really a matter of style whether you declare the returned pointer to be const or not. However, the code should be consistent and use the same style for both const and non-const overload of operator [].

[alanjhd08]

Hi D_Drmmr,

Agreed that the const [] operator will be needed, and used if the array is const. My point was that if the array is not const, the const [] operator won't be used.
The OP suggested that it was required in order

..specifically to enable a calling function to assign the return value to a const pointer, e.g.

T const * const tp = arr2d[n];

which is not the case.

Thanks for explaining the 2nd const. I got a warning from the Comeau complier saying it would be ignored, so I'm going to go read up on that.

[superbonzo]

It has the 'effect' that you cannot write code like ...

actually, it would have been an error even if the second const were omitted, because rvalues of scalar types ( that include pointers ) are non modifiable ( hence the Comeau warning experienced by alanjhd08 ) ...

[r.stiltskin]

LOL. You all have cleared up my confusion about the third const, and I see that I was mistaken about the first two.

So now I understand that the third const is needed just in the case that the array itself has been declared const.

And I see that I all of these assignments

T* tp1 = arr[0];
const T* tp2 = arr[0];
const T* const tp3 = arr[0];

are legal with or without the first and/or second const in the operator.


And I see that I can't write something like, say

cout << ++arr[0];

with or without the first and/or second const

And I see that the first const is needed to prevent using the returned pointer to alter the const array.

So we're left with the second const which seems to be unnecessary. Agreed?

[alanjhd08]

Hi,

And I see that the first const is needed to prevent using the returned pointer to alter the const array.

Yes, without the first const you could do something like this:

void foo(const dynamic_2d_array<int>& myArray)
{
    myArray[0][0] = 1;
}

which shouldn't be allowed.

Alan