inheriting the operator<<

[johnmmcparland]

Hi all,

when I write a subclass, can I inherit its superclass' << operator?

As an example say we have two classes, Person and Employee.

class Person has the << operator;

/**
* Insertion operator
* @param o The output stream to insert a person into
* @param p The person to insert into a stream
*/
ostream& operator<<(ostream& o, Person& p)
{
o << p.m_surname << ", " << p.m_firstname;
if (p.m_middlename != "")
o << p.m_middlename;
o << " (" << p.m_dob << ") " << "[";
if (p.m_gender == Person::male)
o << "M";
else if (p.m_gender == Person::female)
o << "F";
else // Shouldn't happen
o << " ";
o << "]";
return o;
}
 

Now in class Employee I want this same behaviour plus some extra
behaviour for the fields which Employee has and Person doesn't;

/**
* Output to a stream
*
* @param o The output stream to write to
* @param emp The employee to write to an output stream
*/
ostream& operator<<(ostream& o, Employee& emp)
{
o= Person::operator<<(o,emp);
o << std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;
return o;
}
 

I would have thought that since Person::operator() returns an ostream&
that assigning it to the existing o would be ok. However it isn't as
this compiler message informs me;

operator<< is not a member of Person
 

Now I understand this since it is not a member function as it is
declared as follows;

friend ostream& operator<<(ostream& o, Person& p);
 

in person.hpp.

So how do I get round this problem? Basically I want to take the
returned ostream& from class Person's operator<< method and insert it
into the ostream& object in class Employee's operator<< method.

Thank,

John

[niklasb]

On Mar 22, 8:54 am, "johnmmcparland" <[e-mail]>
wrote:

Hi all,

when I write a subclass, can I inherit its superclass' << operator?

As an example say we have two classes, Person and Employee.

class Person has the << operator;

[code]
/**
* Insertion operator
* @param o The output stream to insert a person into
* @param p The person to insert into a stream
*/
ostream& operator<<(ostream& o, Person& p)

This operator is not a member. It's an overloaded operator<< that
takes a
Person& as its second argument. (Incidentally, the second parameter
should
probably be declared const.)

ostream& operator<<(ostream& o, Employee& emp)
{
o= Person::operator<<(o,emp);
o << std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;
return o;}

And here you're not *overriding* the base class' operator<< (you can't
override a non-member). You're defining another overloaded operator<<
that
takes an Employee& as its second argument.

In the first statement above you're trying to call the operator<< for
person as if it were a member function. It should be written

operator<<(o, static_cast<Person&>(emp));

or simply,

o << static_cast<Person&>(emp);

Incidentally, you don't need or want to assign the return value of
operator<<
back to o. It doesn't do what you think. operator<< returns a
reference to the
left hand operand so that you can chain the operator as you've done in
the
second statement above. This, the whole function body could be
written:

o << static_cast<Person&>(emp)
<< std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;

Hope this helps.

--Nick

[Adrian Hawryluk]

ni*****@microsoft.com wrote:

Incidentally, you don't need or want to assign the return value of
operator<<
back to o. It doesn't do what you think. operator<< returns a
reference to the
left hand operand so that you can chain the operator as you've done in
the
second statement above. This, the whole function body could be
written:

o << static_cast<Person&>(emp)
<< std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;

I agree with everything but the function body. You forgot to return the
ostream ;) like this:

return o
<< static_cast<Person&>(emp)
<< std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;

But I'm sure that was just an oversight.

Cheers!
Adrian
--
__________________________________________________ ___________________
\/Adrian_Hawryluk BSc. - Specialties: UML, OOPD, Real-Time Systems\/
\ _---_ Q. What are you doing here? _---_ /
\ / | A. Just surf'n the net, teaching and | \ /
\__/___\___ learning, learning and teaching. You?_____/___\__/
\/______[blog:__http://adrians-musings.blogspot.com/]______\/

[johnmmcparland]

On 22 Mar, 16:59, Adrian Hawryluk <adrian.hawryluk-at-
[e-mail]:

[e-mail] wrote:

Incidentally, you don't need or want to assign the return value of
operator<<
back to o. It doesn't do what you think. operator<< returns a
reference to the
left hand operand so that you can chain the operator as you've done in
the
second statement above. This, the whole function body could be
written:

o << static_cast<Person&>(emp)
<< std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;

I agree with everything but the function body. You forgot to return the
ostream ;) like this:

return o
<< static_cast<Person&>(emp)
<< std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;

But I'm sure that was just an oversight.

Cheers!

Adrian
--
__________________________________________________ ___________________
\/Adrian_Hawryluk BSc. - Specialties: UML, OOPD, Real-Time Systems\/
\ _---_ Q. What are you doing here? _---_ /
\ / | A. Just surf'n the net, teaching and | \ /
\__/___\___ learning, learning and teaching. You?_____/___\__/
\/______[blog:__http://adrians-musings.blogspot.com/]______\/

Thanks Guys. The cast you suggested Nick was what I was looking for.
I had tried a different cast (Java style - (Person)emp) but this had
failed. Maybe its time I re-read my notes on C++ casts.

John

[James Curran]

On Mar 22, 11:54 am, "johnmmcparland" <[e-mail]>
wrote:

when I write a subclass, can I inherit its superclass' << operator?
As an example say we have two classes, Person and Employee.
class Person has the << operator;

My way of dealing with this:

class Person
{
// :
virtual void Output(ostream& o) const
{
o << m_surname << ", " << m_firstname;
if (m_middlename != "")
o << m_middlename;
o << " (" << m_dob << ") " << "[";
// etc....
}
};

class Employee : public Person
{
// :
virtual void Output(ostream& o) const
{
Person::Output(o);
o << std::endl << "Started: " << m_startDate
<< " Role: " << m_job << "Dept: " << m_department
<< std:: endl << "Salary: " << m_salary << std::endl;
}
};
template<typename T>
ostream& operator<<(ostream& o, const T& t)
{
t.Output(o);
return o;
}

No ugly casting. Nothing needs to be a friend. Easily Extendable.

[Ian Collins]

johnmmcparland wrote:

Hi all,

when I write a subclass, can I inherit its superclass' << operator?

Yet another alternative:

struct Streamable
{
virtual void output( std::ostream& ) const = 0;
};

std::ostream& operator<<( std::ostream& out,
const Streamable& s ) const
{
s.output( out );
return out;
}

And derive your Person from Streamable.

--
Ian Collins.

[niklasb]

On Mar 22, 9:59 am, Adrian Hawryluk <adrian.hawryluk-at-
[e-mail]:

>
I agree with everything but the function body. You forgot to return the
ostream ;) like this:

return o
<< static_cast<Person&>(emp)
<< std::endl << "Started: " << emp.m_startDate
<< " Role: " << emp.m_job << "Dept: " << emp.m_department
<< std:: endl; << "Salary: " << emp.m_salary << std::endl;

But I'm sure that was just an oversight.

Yep. Thanks for catching it. :-)