(This is not a question about overloading operator. in general.)
We know that there are many good reasons to use setter and getter methods.
Well, then, it seems strange to me these are not customization points of member access i.e. if class A has a data member x, then the use of x in an lvalue context will not really just use x, but rather call some method (say A::get_x_lvalue(), never mind the syntax) which defaults to
typename std::add_reference<decltype(x)>::type A::get_x_lvalue() { return x; }
and can be implemented as an override, and similarly when x is used in a prvalue constant will call an overridable
decltype(x) A::get_x_prvalue() const { return x; }
... analogously to, say, how you do this in Javascript.
My question are:
- Historically, why was this not added to the language along with customizable copy constructors, assignment operators and destructors?
- Has something like this been officially proposed? If so, what's its status or why was it rejected?
- Are there significant detriments to such a scheme, other than: 1. Slower compilation and 2. Not being able to "trust" the period in my_a.x to be just a plain access?