namespace and operator==

[Xavier Decoret]

The following code does not compoile with gcc-3.2.3

namespace dummy
{
//+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
// Interface of Foo
//+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
class Foo
{
public:

friend bool operator==(cons t Foo& f0,const Foo& f1);
private:
int a_;
};
}
//*************** *************** *************** ***************
// Implementation of Doo
//*************** *************** *************** ***************
bool
operator==(cons t dummy::Foo& f0,const dummy::Foo& f1)
{
return f0.a_ == f1.a_;
}


After a while, I figured that operator== is actually declared in
namespace dummy:: so the compiler error is legitimate. Therefore I can
fix the implementation with:

bool
dummy::operator ==(const dummy::Foo& f0,const dummy::Foo& f1)
{
std::cout<<"in dummy::operator =="<<std::end l;
return f0.a_ == f1.a_;
}

But then I am quite surprise that the following does compile:
int
main(int,char** )
{
dummy::Foo f0;
dummy::Foo f1;
return f0 == f1;
}

Because it should not find the operator== since namespace dummy is not
opened. But I am sure that it is the one called (thanks to the cout).

Then I tried to make operator== be in global namespace with
//+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
// Interface of Foo
//+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
friend bool ::operator==(co nst Foo& f0,const Foo& f1);

//*************** *************** *************** ***************
// Implementation of Doo
//*************** *************** *************** ***************
bool
operator==(cons t dummy::Foo& f0,const dummy::Foo& f1)
{
std::cout<<"in ::operator=="<< std::endl;
return f0.a_ == f1.a_;
}

But then it refuses to compile with:
main.C:11: `bool operator==(cons t dummy::Foo&, const dummy::Foo&)'
should have
been declared inside `::'

So my question is: is my concern legal? Do I really want to have
operator== in namespace dummy? Is it legal that gcc finds that there is
an dummy::operator == even if the namespace is not opened?

Thanks for insights.


--
+-------------------------------------------------+
| Xavier Décoret - Post Doct |
| Graphics Lab (LCS) - MIT |
| mailto: decoret@graphic s.lcs.mit.edu |
| home : http://www.graphics.lc s.mit.edu/~decoret|
+-------------------------------------------------+

[Victor Bazarov]

Re: namespace and operator==

"Xavier Decoret" <decoret@graphi cs.lcs.mit.edu> wrote...[color=blue]
> [...]
> So my question is: is my concern legal?[/color]

It's legal. Whether it's valid or not is a different question.
In order to answer it, one needs to know what your concern is.
[color=blue]
> Do I really want to have
> operator== in namespace dummy?[/color]

I don't know. Do you?
[color=blue]
> Is it legal that gcc finds that there is
> an dummy::operator == even if the namespace is not opened?[/color]

Yes, it is. See 3.4.2/1. The call to operator== is a function
call. Namespaces of the operands are considered in the name
lookup along with all visible scopes.

Victor

[Andrey Tarasevich]

Re: namespace and operator==

Xavier Decoret wrote:[color=blue]
> The following code does not compoile with gcc-3.2.3
>
> namespace dummy
> {
> //+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
> // Interface of Foo
> //+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
> class Foo
> {
> public:
>
> friend bool operator==(cons t Foo& f0,const Foo& f1);
> private:
> int a_;
> };
> }
> //*************** *************** *************** ***************
> // Implementation of Doo
> //*************** *************** *************** ***************
> bool
> operator==(cons t dummy::Foo& f0,const dummy::Foo& f1)
> {
> return f0.a_ == f1.a_;
> }
>
>
> After a while, I figured that operator== is actually declared in
> namespace dummy:: so the compiler error is legitimate. Therefore I can
> fix the implementation with:[/color]

It is not really declared yet. But yes, the above 'friend' declaration
refers to the 'operator ==' from namespace 'dummy'.
[color=blue]
> bool
> dummy::operator ==(const dummy::Foo& f0,const dummy::Foo& f1)
> {
> std::cout<<"in dummy::operator =="<<std::end l;
> return f0.a_ == f1.a_;
> }
>
> But then I am quite surprise that the following does compile:
> int
> main(int,char** )
> {
> dummy::Foo f0;
> dummy::Foo f1;
> return f0 == f1;
> }
>
> Because it should not find the operator== since namespace dummy is not
> opened. But I am sure that it is the one called (thanks to the cout).[/color]

The correct 'operator ==' is found by argument-dependent name lookup.
There's no need to "open" any namespaces here, whatever that means.
[color=blue]
> Then I tried to make operator== be in global namespace with
> //+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
> // Interface of Foo
> //+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++
> friend bool ::operator==(co nst Foo& f0,const Foo& f1);
>
> //*************** *************** *************** ***************
> // Implementation of Doo
> //*************** *************** *************** ***************
> bool
> operator==(cons t dummy::Foo& f0,const dummy::Foo& f1)
> {
> std::cout<<"in ::operator=="<< std::endl;
> return f0.a_ == f1.a_;
> }
>
> But then it refuses to compile with:
> main.C:11: `bool operator==(cons t dummy::Foo&, const dummy::Foo&)'
> should have
> been declared inside `::'[/color]

If I'm not mistaken, you cannot refer to an unknown name in a friend
declaration, unless this name is supposed to belong to immediate
enclosing namespace scope. In other words, you friend declaration can
introduce any names that will (or do already) belong to namespace
'dummy', but if you want to "befriend" anything from global scope, that
thing must be already declared in advance. For example, this will compile

namespace dummy { class Foo; };
bool operator==(cons t dummy::Foo& f0,const dummy::Foo& f1);

namespace dummy
{
class Foo
{
public:
friend bool ::operator==(co nst Foo& f0,const Foo& f1);
private:
int a_;
};
}

bool operator==(cons t dummy::Foo& f0,const dummy::Foo& f1)
{
return f0.a_ == f1.a_;
}

int main()
{
dummy::Foo f0;
dummy::Foo f1;
return f0 == f1;
}
[color=blue]
>
> So my question is: is my concern legal?[/color]

What concern is that?
[color=blue]
> Do I really want to have operator== in namespace dummy?[/color]

Well, you should really ask yourself. It is perfectly legal to have it
there.
[color=blue]
> Is it legal that gcc finds that there is
> an dummy::operator == even if the namespace is not opened?[/color]

Yes, it is. Read about argument-dependent name lookup. Sometimes it is
also referred to as Koenig lookup.

--
Best regards,
Andrey Tarasevich
Brainbench C and C++ Programming MVP