Difference between Operator [] overloading write/read?

Question

I am new to C++ and I am sorry because of this question, but it is a struggle. If someone could help me to distinguish following lines, I would me grateful.

char& operator [](int);         // write (why with reference?)
char operator [](int) const;    //read (why without a reference?)
char const &operator[](int) const; // what is the difference compared to the previous line?
const char *& operator[] (const int* ); // is this also possible?

Answer 1

You might want to read an overview of Operator overloading .

So, to recap some applicable points:

• operator[] is always non-static unary member-function.
• There can be multiple overloads like for any other member-function.
• By convention (heed it!), non-const-qualified versions return a reference for modifying the content (That reference might be represented by a proxy-type, though try to yvoid that).
• By convention, const-qualified overloads can either return a const reference or a copy, to provide read-only access to the same elements.
  • Use a const-reference if the element cannot be dynamically generated, especially if it's not trivially and cheap to copy.
  • Use value-return, if the above does not hold.

BTW: You really want to have the const and non-const members be analogous, so the non-const can be a simple inline-function delegating to the other with the appropriate const_cast.
(Don't do it the other way around, that would not be quite allowed, or safe.)

Regarding your last line, that indexes with a pointer to const int, and returns a reference to a pointer to const char.
That is a seriously odd return-value and index, though if you have a valid use for it, why not?