在继承的模板类中使用下标[]运算符

Question

I have a template class Array<T> with the following three member functions defined.

template <typename T>
const T& Array<T>::GetElement(int index) const {
    if(index_out_of_bounds(index)) throw OutOfBoundsException(index);
    return m_data[index];
}

template <typename T>
T& Array<T>::operator [] (int index) {
    if(index_out_of_bounds(index)) throw OutOfBoundsException(index);
    return m_data[index];
}

template <typename T>
const T& Array<T>::operator [] (int index) const {
    if(index_out_of_bounds(index)) throw OutOfBoundsException(index);
    return m_data[index];
}

Next I have another template class NumericArray<T> that inherits from Array<T> . This class contains an overloaded operator + .

template <typename T>
NumericArray<T> NumericArray<T>::operator + (const NumericArray<T> &na) const {
    unsigned int rhs_size = this -> Size(), lhs_size = na.Size();
    if(rhs_size != lhs_size) throw SizeMismatchException(rhs_size, lhs_size);

    NumericArray<T> array_sum(rhs_size);

    for(unsigned int i = 0; i < rhs_size; i++) {
        array_sum[i] = this[i] + na[i];
    }

    return array_sum;
}

Now suppose I instantiate two instances of NumericArray<T> in main.cpp where T is of type int . Both instances have already been populated with integer values.

If I now try to perform the + operator I get the following error message:

../NumericArray.tpp:44:16: error: cannot convert 'NumericArray' to 'int' in assignment array_sum[i] = this[i] + na[i];

However, if I go back and change the implementation in the for loop of the overloaded operator+ in NumericArray<T> to the following. The operator does as expected.

array_sum[i] = this -> GetElement[i] + na.GetElement[i];

Why is the subscript operator [] not behaving the same if they have equivalent implementations?

Answer 1

The issue is that you're attempting to apply operator [] on a pointer type:

 for(unsigned int i = 0; i < rhs_size; i++) {
        array_sum[i] = this[i] + na[i];

Since this is a pointer, you must either

1) dereference the pointer first to apply the overloaded operator.

or

2) apply the -> operator and use the operator keyword to access the overloaded operator.

Here is an illustration of the two possible solutions:

    array_sum[i] = (*this)[i] + na[i];

or

    array_sum[i] = this->operator[](i) + na[i];

with the second solution, the this is not necessary:

    array_sum[i] = operator[](i) + na[i];