My question is about the difference between:
const T& operator[](const int nIndex) const;
and:
T& operator[](const int nIndex);
Why would I need both of them defined in a class, what's the purpose? Wouldn't the latter suffice?
My question is about the difference between:
const T& operator[](const int nIndex) const;
and:
T& operator[](const int nIndex);
Why would I need both of them defined in a class, what's the purpose? Wouldn't the latter suffice?
The first one
is a constant method(function) ie it guarantees that it would not change any of the class member variable(unless its mutable).
It also returns a constant object which means you can call only constant function i.e you can call only functions that have const at the end similar to the one above.
This method may change the member variables and returns an object that can call any class methods.
We need them both because the constant object would be using the constant method and non constant would be using the other one.
If the object you're accessing is
const
, you don't want to be able to modify it. The compiler wouldn't let you call the non-const
version of the function.Those are member functions of a class, and the version will be chosen based on whether that class in used as a
const
context.This version will be called when
[]
is used on a object in aconst
context. It preserves theconst
-ness of the returned element.This version will be called when
[]
is used on a non-const
object. It specifies that when your object isn'tconst
, you'll get an element that you can modify, allowing code likemyObject[0] = 10;
A member function declaration with
const
at the end of it allows that function to be called even on aconst
object. This only makes sense for member functions that don't modify the state of the object.Let's say the class you have that overloads these operators is called
X
. Presumably it behaves a bit like a container, giving access to the elements it contains through thisoperator[]
.Now let's say the user wants to use a
const X
:Should the user be allowed to do this? Probably. If they want a container that is immutable, then let them have it. If you didn't provide the
const
version ofoperator[]
, they wouldn't be able to do this. They're not trying to modify the container after all, they're just looking at its contents.Now why make the
const
version ofoperator[]
return aconst
reference? Because it has to. It's returning a reference to a member of the class itself. If the container wasconst
and returned a non-const
reference, the caller would be able to modify its internals just by using this operator:Oh dear, we modify the state of
x
even though it'sconst
. This would be bad and in fact, the compiler won't even let you do it.