如何为模板化的 function 重载 []

Question

I'm tasked with improving C arrays by implementing an array class with various functionality. I'm trying to overload '[]' but I've ran into an issue.

template<typename T>
class SA{
private:
  T* pT;
//other vars...

public: 
//other initialization functions...
int& operator [](int offset);
};

template<typename T>
int& SA<T>::operator [](int offset){
  if (offset < lIdx || offset > hIdx){
    std::cout << "invalid index:" << std::endl;
  }

  return pT[offset];
}

int main(){
  SA<float> thing1(15);
  thing1[5] = 5;
  return 0;

When I use this overloading function, I'm met with this error:

error: cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'

However, if I understand correctly I can't re-assign the value at this index with '=' if I remove the '&'. The compiler will also throw this error if I do so:

error: lvalue required as left operand of assignment

What am I supposed to do here?

Answer 1

The return type of the function should be T& , not int& :

T& operator [](int offset);

Also note that, while it is nice that you check to make sure the index is in range, you don't actually do anything about it. One solution is to throw an exception:

#include <stdexcept>

template <typename T>
T& SA<T>::operator[](int offset) {
  if (offset < lIdx || offset > hIdx)
    throw std::out_of_range{"Array index out of range"};
  return pT[offset];
}

If you really want to be consistent with STL containers, let operator[] be unchecked, and add a debug-time check like:

#include <cassert>

template <typename T>
T& SA<T>::operator[](int offset) noexcept { // note noexcept
  assert(offset < lIdx || offset > hIdx);
  return pT[offset];
}

Adding a const-overload of this operator would also be nice:

const T& operator [](int offset) const noexcept;

Answer 2

first you should adjust the return type according to your value type:

template<typename T>
T& SA<T>::operator [](int offset){
  if (offset < lIdx || offset > hIdx){
    std::cout << "invalid index:" << std::endl;
  }

  return pT[offset];
}

Then if you want it to also work in constant mode add the following overload:

template<typename T>
const T& SA<T>::operator [](int offset)const{
  if (offset < lIdx || offset > hIdx){
    std::cout << "invalid index:" << std::endl;
  }

  return pT[offset];
}