Hi @vaporeon_, a while ago we talked about the fact that references were introduced to C++ in order to enable operator overloading. You asked why you have to introduce references to enable this and I said that you didn't and it was an unnecessary complication.

I've been thinking about this and I don't agree anymore.

In C++, operators used with class types are syntactic sugar for method calls:

#include <iostream>

class NumWrapper {
public:
    int val;
    NumWrapper(int n) : val(n) {} 
    NumWrapper operator+(NumWrapper& r) { return NumWrapper(this->val + r.val); }
};

int main() {
    NumWrapper l(3);
    NumWrapper r(4);

    std::cout << (l + r).val << "\n";
    std::cout << l.operator+(r).val << "\n";
}

So why not make the overload method take pointers instead?

class NumWrapper {
public:
    int val;
    NumWrapper(int n) : val(n) {}
    // why didn't c++ implement operator overloads like this?
    NumWrapper operator+(NumWrapper* r) { return NumWrapper(this->val + r->val); }
};

Well, imagine we used an rvalue as one of the + operands. Then a pointer to an rvalue would be passed to the overload function. rvalues normally have their addresses hidden from the programmer (you can't give them to &). Then operator overloading would circumvent this feature and allow the programmer to access the address of an rvalue.

I currently believe that references were introduced so that C++ could have a pointer-like language construct that does not expose the addresses of rvalues.