Why assignment operator return by reference?

[DyslexicChciken]

I have code here that uses assignment operators that doesn't return by reference and it still works. So why does my book say you need to return by reference?

Here is a quote from my book:

The return type of operator= is a reference to the invoking object, so as to allow chained
assignments a=b=c.

The code below is from my book. I simply removed '&', in the original code that has assignment operators return by reference, from IntCell & operator=. This way the assignment operator no longer returns a reference, and it still works.

#include <iostream>

using namespace std;

class IntCell
{
	public:
	explicit IntCell( int initialValue = 0 )
	{ storedValue = new int{ initialValue }; }

	~IntCell( ) // Destructor
	{ delete storedValue; }

	IntCell( const IntCell & rhs ) // Copy constructor
	{ storedValue = new int{ *rhs.storedValue }; }

	IntCell( IntCell && rhs ) : storedValue{ rhs.storedValue } // Move constructor
	{ rhs.storedValue = nullptr; }

        //Notice function type is not a reference.
	IntCell operator= ( const IntCell & rhs ) // Copy assignment
	{
		if( this != &rhs )
		*storedValue = *rhs.storedValue;
		return *this;
	}

        //Notice function type is not a reference.
	IntCell operator= ( IntCell && rhs ) // Move assignment
	{
		std::swap( storedValue, rhs.storedValue );
		return *this;
	}

	int read( ) const
	{ return *storedValue; }

	void write( int x )
	{ *storedValue = x; }

	private:
	int *storedValue;
};

int main()
{

	IntCell x;
	IntCell y{2};
	IntCell z{3};

	x = y = z;
	cout << "x = " << x.read() << endl;
	cout << "y = " << y.read() << endl;
	cout << "z = " << z.read() << endl;

	return 0;
}

[Disch]

Returning by value will work, but you are making unnecessary copies every time the = operator is called, so it isn't preferable.

[DyslexicChciken]

Returning by value will work, but you are making unnecessary copies every time the = operator is called, so it isn't preferable.

So what the author wrote was just misleading. I knew it would work even though it would be inefficient, but the author gave the impression that I had to use return by reference.

[MiiNiPaa]

If you write (x = y) = z;, returning by reference and value would have different behavior.

For assigment operator it really does not matter, aside form inefficiency and principle of least astonishment: any person would expect some concrete behavior from something like:
(x = y).set_field(5);