Overloaded stream insertion operator << in C++

Ken H

13y6.7k

hi friend,
    i have a program,but i do not understand function overloading reference type.

code,see below:
#include
#include
using namespace std;
class Employee
{
public:
    Employee(char *n,char *s,int a,char *depar,double sal)
{
  strcpy(Name,n);
  strcpy(Sex,s);
  strcpy(Department,depar);
  Age=a;
  Salary=sal;
}
friend ostream& operator<<(ostream&,Employee&);
private:
char Name[10];
char Sex[6];
int Age;
char Department[14];
double Salary;
};
ostream& operator<<(ostream& stream,Employee& obj)//why function return values and first parameter in use a reference type?
                                                                                              //I want to know what they represent and execution process?
{
    stream<<"Name:"<    stream<<"Sex:"<    stream<<"Age:"<    stream<<"Department:"<    stream<<"Salary:$"<    return stream;
}
int main()
{
        Employee emp1("AA","Male",23,"SoftDevelop",6300.5),
       emp2("BB","Male",35,"SoftDdevlop",4000);
       cout<<"\t\tEmployee Information\t\t"<<"\n";
       cout<       return 0;
}

thanks

7 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes13y ago
Accepted answer
If you change the code in that way, then you will get a compiler error because Stream (which the function is returning) is a reference to an ostream object, not an ostream object.

But, if you change the return type to void (including in the 'friend' declaration) and remove the line:

return stream;

then it will compile and run fine:

void operator<<(ostream& stream,Employee& obj)
{
stream<<"Name:"<
stream<<"Sex:"<
stream<<"Age:"<
stream<<"Department:"<
stream<<"Salary:$"<
}

However, if you then change:

cout<
to:

cout<
then it won't compile because the expression:

cout<
now has a void return type (rather than ostream&) and so can't appear before another << operator.

This is what I meant when I said that the return type of the operator overload needs to be ostream& so it can used within a larger input/output expression.
Ken H13y ago
thank for Vulpes.
Vulpes13y ago
Yes, I think you've grasped it now :)

In this line:

cout<

the first << has operands of cout and emp1 and so uses the overloaded operator and then returns cout.

The second << then has operands of cout and "\n-------------------\n" and so uses the meaning of the operator when the second argument is a string (i.e. it just outputs the string) and again returns cout.

Finally, The third << has operands of cout and emp2 and so again uses the overloaded operator and returns cout. As there are no more operators, the returned stream reference is now discarded.
Ken H13y ago
i can understand it:this function returns the value of using ostream reference, so it is delegate current "stream" value?
Its execution diagram below:

thanks
Ken H13y ago
thanks.
Ken H13y ago
hi Vulpes,
    Other I understand, Below I do not understand:
Having a return value equal to the reference parameter might seem pointless at first but it enables the stream object to be used within a larger input/output expression.

will change code follows:

ostream operator<<(ostream& stream,Employee& obj)
{   stream<<"Name:"<    stream<<"Sex:"<    stream<<"Age:"<    stream<<"Department:"<    stream<<"Salary:$"<    return stream;
}
Main function using only a class of objects:
int main()
{
        Employee emp1("AA","Male",23,"SoftDevelop",6300.5);
        cout<<"\t\tEmployee Information\t\t"<<"\n";
        cout<;
        return 0;
}

compile-time error.

thanks
Vulpes13y ago
A reference parameter is used so that any changes you make to the stream object are persisted when the function ends. If you didn't do this, then the stream object would be copied when passed to the function and the copy would be destroyed when the function ended.

Having a return value equal to the reference parameter might seem pointless at first but it enables the stream object to be used within a larger input/output expression.

As the function is not a member of the Employee class it needs to be included as a 'friend' of that class so that it can access its private fields.

Those fields are accessed using the dot operator (rather than the -> operator) as a reference, rather than a pointer, to the object is being used.

When the 'cout' stream is used with an Employee object is now uses the overloaded version of the << operator, rather than the default version.