For example:


cerr < < "You have hit error # " << nErrorNum << endl;


This is broken up like this:


((cerr < < "You have hit error # ") << nErrorNum) << endl;


cerr’s overloaded extraction operator will receive cerr as the “out” parameter, and “You have hit error # ” as a string parameter. When it is done loading the stream, it will return cerr. Then evaluation will continue, and we will have:


(cerr < < nErrorNum) << endl;


cerr’s overloaded extraction operator will receive cerr as the “out” parameter, and nErrorNum as an integer parameter. When it is done putting the value of nErrorNum in the stream, it will return cerr again, and evaluation will continue:


cerr < < endl;


Again, cerr’s overloaded extraction operator will receive cerr as the “out” parameter, and endl as it’s other parameter. It will do it’s thing, return cerr, and evaluation will continue. At this point, there’s nothing left to evaluate, so evaluation is complete.

If we had returned cout instead of out, then nErrorNum and endl would have been printed to cout instead of cerr!

I don’t understand why this:

ostream& operator< < (ostream &out, Point &cPoint)
 {
     out << "(" << cPoint.GetX() << ", " <<
         cPoint.GetY() << ", " <<
         cPoint.GetZ() << ")";
     return out;
 }

isn’t written like this:

ostream& operator< < (ostream &out, Point &cPoint)
 {
     cout << "(" << cPoint.GetX() << ", " <<
         cPoint.GetY() << ", " <<
         cPoint.GetZ() << ")";
     return cout;
 }

I guess I don’t get the difference between “out” and “cout”.

????

Thanks. ]]> http://www.learncpp.com/cpp-tutorial/93-overloading-the-io-operators/#comment-8920 Learn C++ - » 13.2 -- Input Wed, 05 Mar 2008 00:09:27 +0000 http://www.learncpp.com/cpp-tutorial/93-overloading-the-io-operators/#comment-8920 [...] extraction operations for all of the built-in data types, and you’ve already seen how you can overload the extraction operator for your own [...] [...] extraction operations for all of the built-in data types, and you’ve already seen how you can overload the extraction operator for your own [...]

Pretty much everything you’ve learned about pass by value, reference, and address apply to return values in the same way that they apply to parameters.

#include 
using namespace std;

int x = 11;

int& ref()
	{
	return x;
	}

int main()
	{
	int *ptr = &ref();  //after the return by reference
                      //takes place, &ref() is &x

	*ptr = 12;
	cout < < x << endl;

	return 0;
	}

Let’s say you wrote a class named Foo.

If you are writing a function that lives outside of Foo:

Foo& FunctionName(Foo& cFoo, other params here)
{
    // use cFoo
    return cFoo;
}

If writing a function that is a member of Foo:

Foo& Foo::FunctionName(other params here)
{
    // use implicit Foo object
    return *this;
}

Curiosity killed the cat! :)

Since ostream is a class, ostream& is a reference to an ostream class. Note that we’re also taking an ostream& as a parameter. ostream is typically passed by reference because we don’t want to make a copy of it as we pass it around.

So basically, our overloaded function takes an ostream as a parameter, writes stuff to it, and then returns the same ostream. This allows us to chain < < calls together:


cout < < cPoint1 << cPoint2 << cPoint3;


This resolves as follows:


((cout < < cPoint1) << cPoint2) << cPoint3;


cout < < cPoint1 is resolved first, with cout becoming the ostream& parameter. When this overloaded function is finished writing to the out parameter, it returns that cout so the next call to < < can use it. Thus:


((cout < < cPoint1) << cPoint2) << cPoint3;


becomes:


(cout < < cPoint2) << cPoint3;


becomes:


cout < < cPoint3;


This calls our overloaded function one last time. At the end of this function, cout is again returned. But there’s nobody left to use it, so the return value is ignored. The expression ends, and the program moves to the next line.