赋值运算符的返回类型是什么？

Question

I am just starting C++. I am a bit confused about the return type of assignment and dereference operator. I am following the book C++ Primer. At various occasions, the author says that the return type of assignment operator is reference to the type of left hand operand but later on, he says that the return type is the type of the left hand operand. I have referred C++11 Standard Sec. 5.17, where the return type is described as "lvalue referring to left hand operand".

Similarly, I can't figure out whether dereference returns the pointed-to object or the reference to the object.

Are these statements equivalent? If so, then how? Any explanation would be appreciated.

Answer 1

The standard correctly defines the return type of an assignment operator. Actually, the assignment operation itself doesn't depend on the return value - that's why the return type isn't straightforward to understanding.

The return type is important for chaining operations. Consider the following construction: a = b = c; . This should be equal to a = (b = c) , ie c should be assigned into b and b into a . Rewrite this as a.operator=(b.operator=(c)) . In order for the assignment into a to work correctly the return type of b.operator=(c) must be reference to the inner assignment result (it will work with copy too but that's just an unnecessary overhead).

The dereference operator return type depends on your inner logic, define it in the way that suits your needs.

Answer 2

They can both be anything, but usually operator = returns the current object by reference, ie

A& A::operator = ( ... )
{
   return *this;
}

And yes, "reference to the type of left hand operand" and "lvalue referring to left hand operand" mean the same thing.

The dereference operator can have basically any return type. It mostly depends on the logic of the program, because you're overloading the operator that applies to an object, not to a pointer to the object. Usually, this is used for smart pointers, or iterators, and return the object they wrap around:

struct smart_ptr
{
   T* innerPtr;
   T* smart_ptr::operator* ()
   {
      return innerPtr;
   }
}

smart_ptr p; 
T* x = *p;  

Answer 3

I have seen similar issues, but I guess it would be best to use

X& X::operator=(const X&);

Using this, you will be able to reuse the object in a chain-assignment.