473,398 Members | 2,812 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,398 software developers and data experts.

Why operator<< should be friend or global, non-member function.

>From a book, I know the following is true for the comparison operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions for
operators << and >you have to write:
someclass << cout;
someclass >cin;
?

Thus you usually make them friends so you avoid have to use cin and
cout
in such a weird manner.

/ E

Nov 8 '06 #1
7 2766
Eric Lilja wrote:
>From a book, I know the following is true for the comparison
operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions for
operators << and >you have to write:
someclass << cout;
someclass >cin;
<BTWActually, I'd expect the "arrows" to be reversed here, IOW

someclass >cout;
someclass << cin;

to correctly show the "direction" of the data flow. </BTW>
?
No, it is not. The actual reason is that if you wanted them as members,
they would have to be members of 'ostream' or 'istream', to which you
have no access. That's why they are usually made non-members. Nobody
in their right mind thinks of making them members of the class to be
streamed.
Thus you usually make them friends so you avoid have to use cin and
cout
in such a weird manner.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Nov 8 '06 #2

Victor Bazarov skrev:
Eric Lilja wrote:
From a book, I know the following is true for the comparison
operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions for
operators << and >you have to write:
someclass << cout;
someclass >cin;

<BTWActually, I'd expect the "arrows" to be reversed here, IOW
Oops, sorry about that.
>
someclass >cout;
someclass << cin;

to correctly show the "direction" of the data flow. </BTW>
?

No, it is not. The actual reason is that if you wanted them as members,
Ok, so which operators is the statement true for (An overloaded
operator that is a class member is only considered when the operator is
used with a *left* operand that is an object of that class.)? Only for
comparison operators?
they would have to be members of 'ostream' or 'istream', to which you
have no access. That's why they are usually made non-members. Nobody
in their right mind thinks of making them members of the class to be
streamed.
Thus you usually make them friends so you avoid have to use cin and
cout
in such a weird manner.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
/ E

Nov 8 '06 #3

Victor Bazarov skrev:
Eric Lilja wrote:
From a book, I know the following is true for the comparison
operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions for
operators << and >you have to write:
someclass << cout;
someclass >cin;

<BTWActually, I'd expect the "arrows" to be reversed here, IOW

someclass >cout;
someclass << cin;

to correctly show the "direction" of the data flow. </BTW>
?

No, it is not. The actual reason is that if you wanted them as members,
they would have to be members of 'ostream' or 'istream', to which you
have no access. That's why they are usually made non-members. Nobody
in their right mind thinks of making them members of the class to be
streamed.
But wait a minute, it is reason then. You seemed to say that the
statement "An overloaded operator that is a class member is only
considered when the operator is used with a *left* operand that is an
object of that class." is false.
In the form cout << myclass; cout is the left operand, that's why you
said I'd have to change ostream or istream. So the statement above is
true for operator << and >too.
>
Thus you usually make them friends so you avoid have to use cin and
cout
in such a weird manner.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
/ E

Nov 8 '06 #4
Eric Lilja wrote:
Victor Bazarov skrev:
>Eric Lilja wrote:
>>>From a book, I know the following is true for the comparison
operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions
for operators << and >you have to write:
someclass << cout;
someclass >cin;

<BTWActually, I'd expect the "arrows" to be reversed here, IOW

someclass >cout;
someclass << cin;

to correctly show the "direction" of the data flow. </BTW>
>>?

No, it is not. The actual reason is that if you wanted them as
members, they would have to be members of 'ostream' or 'istream', to
which you have no access. That's why they are usually made
non-members. Nobody in their right mind thinks of making them
members of the class to be streamed.

But wait a minute, it is reason then. You seemed to say that the
statement "An overloaded operator that is a class member is only
considered when the operator is used with a *left* operand that is an
object of that class." is false.
Huh?

struct A {
A(int);
void operator+(A const&) const;
};

int main() {
A a(42);
a + 73; // compiles OK
666 + a; // cannot compile
}

'666 + a' does not compile because the compilers don't try to convert
the left operand to 'A' (here). That's why in order for '666 + a' to
compile, you need the operator+ to be non-member:

struct A {
A(int);
};

void operator+(A const&, A const&);

int main() {
A a(42);
a + 73; // compiles OK
666 + a; // compile OK
}
In the form cout << myclass; cout is the left operand, that's why you
said I'd have to change ostream or istream. So the statement above is
true for operator << and >too.
You lost me.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Nov 8 '06 #5

Victor Bazarov skrev:
Eric Lilja wrote:
Victor Bazarov skrev:
Eric Lilja wrote:
From a book, I know the following is true for the comparison
operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions
for operators << and >you have to write:
someclass << cout;
someclass >cin;

<BTWActually, I'd expect the "arrows" to be reversed here, IOW

someclass >cout;
someclass << cin;

to correctly show the "direction" of the data flow. </BTW>

?

No, it is not. The actual reason is that if you wanted them as
members, they would have to be members of 'ostream' or 'istream', to
which you have no access. That's why they are usually made
non-members. Nobody in their right mind thinks of making them
members of the class to be streamed.
But wait a minute, it is reason then. You seemed to say that the
statement "An overloaded operator that is a class member is only
considered when the operator is used with a *left* operand that is an
object of that class." is false.

Huh?

struct A {
A(int);
void operator+(A const&) const;
};

int main() {
A a(42);
a + 73; // compiles OK
666 + a; // cannot compile
}

'666 + a' does not compile because the compilers don't try to convert
the left operand to 'A' (here). That's why in order for '666 + a' to
compile, you need the operator+ to be non-member:

struct A {
A(int);
};

void operator+(A const&, A const&);

int main() {
A a(42);
a + 73; // compiles OK
666 + a; // compile OK
}
In the form cout << myclass; cout is the left operand, that's why you
said I'd have to change ostream or istream. So the statement above is
true for operator << and >too.

You lost me.
Hehe, ok, I'll try to be a bit more clearer. Just trying to understand
why operator<< (and >>) "has to be" non-member functions for
user-introduced classes if you want to be able to use input and output
streams with objects of those classes in the normal way.
Say we have a class A and we have an instance of A named "a" and we do:
cout << a;
The compiler first check for a global function returning an
ostream-reference and taking two arguments: reference to an ostream and
const reference to class A.
If it finds no such function it translates the call to
cout.operator<<(a) but that fails because ostream doesn't have a member
operator<< that takes our class A. Or maybe it checks the other way
around.
If we make operator<< a member of A we have to write a.operator<<(cout)
or a << cout;
Thus, the solution is to write a global operator<< (usually declared as
friend for easy access to the class private data members).
Is this "analysis" correct or at least somewhat correct?
>
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
/ E

Nov 9 '06 #6

Eric Lilja wrote:
From a book, I know the following is true for the comparison operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions for
operators << and >you have to write:
someclass << cout;
someclass >cin;
?

Thus you usually make them friends so you avoid have to use cin and
cout
in such a weird manner.
Avoid making them friends.

Nov 9 '06 #7
Eric Lilja wrote:
Victor Bazarov skrev:
>Eric Lilja wrote:
>>Victor Bazarov skrev:

Eric Lilja wrote:
>From a book, I know the following is true for the comparison
>operators:
An overloaded operator that is a class member is only considered
when the operator is used with a *left* operand that is an object
of that class.
And is that also the reason why if you use class member functions
for operators << and >you have to write:
someclass << cout;
someclass >cin;

<BTWActually, I'd expect the "arrows" to be reversed here, IOW

someclass >cout;
someclass << cin;

to correctly show the "direction" of the data flow. </BTW>

?

No, it is not. The actual reason is that if you wanted them as
members, they would have to be members of 'ostream' or 'istream',
to which you have no access. That's why they are usually made
non-members. Nobody in their right mind thinks of making them
members of the class to be streamed.

But wait a minute, it is reason then. You seemed to say that the
statement "An overloaded operator that is a class member is only
considered when the operator is used with a *left* operand that is
an object of that class." is false.

Huh?

struct A {
A(int);
void operator+(A const&) const;
};

int main() {
A a(42);
a + 73; // compiles OK
666 + a; // cannot compile
}

'666 + a' does not compile because the compilers don't try to convert
the left operand to 'A' (here). That's why in order for '666 + a' to
compile, you need the operator+ to be non-member:

struct A {
A(int);
};

void operator+(A const&, A const&);

int main() {
A a(42);
a + 73; // compiles OK
666 + a; // compile OK
}
>>In the form cout << myclass; cout is the left operand, that's why
you said I'd have to change ostream or istream. So the statement
above is true for operator << and >too.

You lost me.

Hehe, ok, I'll try to be a bit more clearer. Just trying to understand
why operator<< (and >>) "has to be" non-member functions for
user-introduced classes if you want to be able to use input and output
streams with objects of those classes in the normal way.
Well, actually, no. You can define your own stream class wrapping
standard stream, then you will be able to add your own operators to
it and "forward" them in any way you want to the wrapped stream.
Say we have a class A and we have an instance of A named "a" and we
do: cout << a;
OK. That's what we do usually.
The compiler first check for a global function returning an
ostream-reference and taking two arguments: reference to an ostream
and const reference to class A.
It first checks the member, actually.
If it finds no such function it translates the call to
cout.operator<<(a) but that fails because ostream doesn't have a
member operator<< that takes our class A. Or maybe it checks the
other way around.
Right. The other way.
If we make operator<< a member of A we have to write
a.operator<<(cout) or a << cout;
Well, yes, but nobody does it that way.
Thus, the solution is to write a global operator<< (usually declared
as friend for easy access to the class private data members).
Is this "analysis" correct or at least somewhat correct?
Nah, it's fine. You got it.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Nov 9 '06 #8

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

4
by: Dan | last post by:
Hi, I would just like to know if the istream operator takes only one parammeter(object) at a time (like z) ? istream operator>>(istream& in, Shape &z) Cause I keep getting error concerning the...
3
by: Alicia | last post by:
Hello, I am trying to figure out how to call an overloaded operator<< inherited from a base class. #ifndef PHONECALL #define PHONECALL #include "time.h" #include "interval.h"
5
by: Gianni Mariani | last post by:
Can anyone enligten me why I get the "ambiguous overload" error from the code below: friendop.cpp: In function `int main()': friendop.cpp:36: ambiguous overload for `std::basic_ostream<char,...
5
by: Eric Lilja | last post by:
Ok, this code doesn't compile: #include <iostream> #include <ostream> /* Just for you, Mike :-) */ template<typename T> class Couple { public: Couple(const T& ax, const T& ay) : x(ax), y(ay)...
4
by: Rock | last post by:
I'm in the process of writing this program for complex numbers and I use DevC++. My professor on the other hand compiles on Borland 5.5. So I ocasionally save and run my work on Borland to see if...
2
by: Harry | last post by:
Hi all, I am writing a logger program which can take any datatype. namespace recordLog { enum Debug_Level {low, midium, high}; class L { std::ofstream os; Debug_Level cdl; const...
3
by: Yudan Yi \(OSU\) | last post by:
I have a question to define a friend operator<< for a class. for example, I can define friend ostream& operator<<(ostream& os, const TTest& x) { ...; return (os); }; While I want to add more...
2
by: ryan_melville | last post by:
Hi, Should I put the operator<<() for my class (which is in a namespace) in the namespace or make it global? If I understand the lookup rules correctly: If I make it global, it may be hidden...
5
by: noone | last post by:
hi. I don't use exceptions much in the embedded world, but for my plugin interface to a hardware MPEG encoder I'd like to, since there are so many places that the crummy kernel driver can do bad...
1
by: Stuart Golodetz | last post by:
Hi guys, I'm trying to making an instance of a templated operator<< for a templated class a friend of that class (see below), to allow it to access the class internals for output purposes. ...
0
by: Charles Arthur | last post by:
How do i turn on java script on a villaon, callus and itel keypad mobile phone
0
BarryA
by: BarryA | last post by:
What are the essential steps and strategies outlined in the Data Structures and Algorithms (DSA) roadmap for aspiring data scientists? How can individuals effectively utilize this roadmap to progress...
1
by: nemocccc | last post by:
hello, everyone, I want to develop a software for my android phone for daily needs, any suggestions?
1
by: Sonnysonu | last post by:
This is the data of csv file 1 2 3 1 2 3 1 2 3 1 2 3 2 3 2 3 3 the lengths should be different i have to store the data by column-wise with in the specific length. suppose the i have to...
0
by: Hystou | last post by:
There are some requirements for setting up RAID: 1. The motherboard and BIOS support RAID configuration. 2. The motherboard has 2 or more available SATA protocol SSD/HDD slots (including MSATA, M.2...
0
marktang
by: marktang | last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However,...
0
Oralloy
by: Oralloy | last post by:
Hello folks, I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>". The problem is that using the GNU compilers,...
0
by: Hystou | last post by:
Overview: Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows...
0
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome a new...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.