operator >> needs to be in namespace std??

[Noah Roberts]

template < typename T >
std::istream & operator >(std::istrea m & in, std::pair<T,T& p)
{
in >p.first >p.second;
return in;
}
....
std::istream_it erator< std::pair<size_ type, size_type
in_beg(std::cin ), in_end;
....
fails to compile. Wrapping the operator >for the pair in namespace
std {} works. Since you're not "allowed" to insert stuff into
namespace std why is that seemingly required and how could this be done
without that?

[Steven T. Hatton]

Noah Roberts wrote:

template < typename T >
std::istream & operator >(std::istrea m & in, std::pair<T,T& p)
{
in >p.first >p.second;
return in;
}
...
std::istream_it erator< std::pair<size_ type, size_type
in_beg(std::cin ), in_end;
...
fails to compile. Wrapping the operator >for the pair in namespace
std {} works. Since you're not "allowed" to insert stuff into
namespace std why is that seemingly required and how could this be done
without that?

Looks like an ADL thing. Care to post a complete example so I can try to
compile it here? I want to be sure I'm doing things exactly as you are.
I'm not sure what the ramifications of std::operator>> (...) might be.

--
NOUN:1. Money or property bequeathed to another by will. 2. Something handed
down from an ancestor or a predecessor or from the past: a legacy of
religious freedom. ETYMOLOGY: MidE legacie, office of a deputy, from OF,
from ML legatia, from L legare, to depute, bequeath. www.bartleby.com/61/

[Gianni Mariani]

Noah Roberts wrote:

template < typename T >
std::istream & operator >(std::istrea m & in, std::pair<T,T& p)
{
in >p.first >p.second;
return in;
}
...
std::istream_it erator< std::pair<size_ type, size_type
in_beg(std::cin ), in_end;
...
fails to compile. Wrapping the operator >for the pair in namespace
std {} works. Since you're not "allowed" to insert stuff into
namespace std why is that seemingly required and how could this be done
without that?

I thought you were allowed to add things to the std namespace (namely
overloads of pre-existing operators - just like this). There was a
discussion about this a couple of years ago, and I do remember two sides
of the argument, however I can't remember how definitive the discussion was.

[Steven T. Hatton]

Gianni Mariani wrote:

Noah Roberts wrote:

>template < typename T >
std::istream & operator >(std::istrea m & in, std::pair<T,T& p)
{
in >p.first >p.second;
return in;
}
...
std::istream_i terator< std::pair<size_ type, size_type
in_beg(std::ci n), in_end;
...
fails to compile. Wrapping the operator >for the pair in namespace
std {} works. Since you're not "allowed" to insert stuff into
namespace std why is that seemingly required and how could this be done
without that?

I thought you were allowed to add things to the std namespace (namely
overloads of pre-existing operators - just like this).

Curiously, this works:

#include <iostream>

template < typename T >
std::ostream& operator<<(std: :ostream& out, std::pair<T,T>& p) {
return out << p.first << p.second;
}
int main() {
std::pair<int,i ntp(1,4);
std::cout<<p<<s td::endl;
}

In truth, even if adding the symbol to std works and is "acceptable ", I
would like to know why it is necessary.

There was a
discussion about this a couple of years ago, and I do remember two sides
of the argument, however I can't remember how definitive the discussion
was.

I defer to the Standard.
--
NOUN:1. Money or property bequeathed to another by will. 2. Something handed
down from an ancestor or a predecessor or from the past: a legacy of
religious freedom. ETYMOLOGY: MidE legacie, office of a deputy, from OF,
from ML legatia, from L legare, to depute, bequeath. www.bartleby.com/61/

[Noah Roberts]

Gianni Mariani wrote:

I thought you were allowed to add things to the std namespace (namely
overloads of pre-existing operators - just like this). There was a
discussion about this a couple of years ago, and I do remember two sides
of the argument, however I can't remember how definitive the discussion was.

Took a sec to find it but it's there:

17.4.3.1 is where it states a program can't add declarations or
definitions to namespace std. However, it states you *can* add
template specializations . "Such a specialization (complete or partial)
of a standard library template results in undefined behavior unless the
declaration depends on a user-defined name of external linkage and
unless the specialization meets the standard library requirements for
the original template."

I'm a little confused here though. Why is it *necissary* that operator

>be defined in namespace std? Does that function qualify as a template specialization?

[White Wolf]

Noah Roberts wrote:

Gianni Mariani wrote:

>I thought you were allowed to add things to the std namespace (namely
overloads of pre-existing operators - just like this). There was a
discussion about this a couple of years ago, and I do remember two sides
of the argument, however I can't remember how definitive the discussion
was.

Took a sec to find it but it's there:

17.4.3.1 is where it states a program can't add declarations or
definitions to namespace std. However, it states you *can* add
template specializations . "Such a specialization (complete or partial)
of a standard library template results in undefined behavior unless the
declaration depends on a user-defined name of external linkage and
unless the specialization meets the standard library requirements for
the original template."

I'm a little confused here though. Why is it *necissary* that operator

>>be defined in namespace std? Does that function qualify as a template
specializatio n?

It does not count as a template specialization. It is a definition of a
brand new template. And I am afraid, reading the text of the standard you
posted, that it is not "legal".

However there is another "rule" you break: do not use std::pair for your own
types. Use them as members, or private inheritance, but not directly as a
user defined type.

For the practical side: if you are only using this printing function as a
debugging tool, I would say you are quite safe and it will work as expected.

....I am just thinking that does a template instance of std::pair count as
user defined type... But I don't think it does. It would not make sense.
But I am not a language lawyer so I might be very wrong.
--
WW aka Attila
:::
Business - the art of extracting money from another man's pocket without
resorting to violence. -- Max Amsterdam

[Stefan Naewe]

White Wolf schrieb:

However there is another "rule" you break: do not use std::pair for your own
types. Use them as members, or private inheritance, but not directly as a
user defined type.

Why not ?

...

Stefan
--
Stefan Naewe
stefan_DOT_naew e_AT_atlas_DOT_ de

[Noah Roberts]

Stefan Naewe wrote:

White Wolf schrieb:

However there is another "rule" you break: do not use std::pair for your own
types. Use them as members, or private inheritance, but not directly as a
user defined type.

Why not ?

bump...

yeah, why not?

[Default User]

Noah Roberts wrote:

>
Stefan Naewe wrote:

White Wolf schrieb:

However there is another "rule" you break: do not use std::pair
for your own types. Use them as members, or private inheritance,
but not directly as a user defined type.

Why not ?

bump...

"Bump"? What does that mean?

Brian

[Bo Persson]

Noah Roberts wrote:

Stefan Naewe wrote:

>White Wolf schrieb:

>>However there is another "rule" you break: do not use std::pair
for your own types. Use them as members, or private inheritance,
but not directly as a user defined type.

Why not ?

bump...

yeah, why not?

Because std::pair isn't a user defined type? :-)

One problem in particular is that it doesn't have operator>and operator<<
defined, and you are formally not allowed to define those inside namespace
std. :-)))

Bo Persson