Help with Koenig Lookup

[REH]

I'm a little confused about argument dependent lookup. Exactly when does
this apply? Specifically, I was hoping to use it to access enumeration
constants. For example:

namespace Flags {
enum flag_type {F1, F2, F3};
}

void foo(Flags::flag _type f)
{
}

int main()
{
foo(F1);
}

All my compilers fail to find "F1" (and they are probably correct). I
thought that Koenig lookup searched for names in the namespaces of the
arguments' types. Now that I think about it, does it look in the namespaces
for the formal or actual arguments?

Thanks.

[Victor Bazarov]

REH wrote:

I'm a little confused about argument dependent lookup. Exactly when does
this apply? Specifically, I was hoping to use it to access enumeration
constants. For example:

namespace Flags {
enum flag_type {F1, F2, F3};
}

void foo(Flags::flag _type f)
{
}

int main()
{
foo(F1);
This has nothing to do with argument-dependent lookup. 'F1' is simply
not present in the scope of the 'main' function.
}

All my compilers fail to find "F1" (and they are probably correct). I
thought that Koenig lookup searched for names in the namespaces of the
arguments' types.
Yes. The namespaces of the arguments are searched for the function names.
So, if you do

namespace Flags {
enum flag_type {F1, F2, F3};
void foo(Flags::flag _type f)
{
}
} // namespace

int main()
{
foo(Flags::F1); // no qualification for 'foo'
}

The compiler will resolve 'foo' as 'Flags::foo' because the argument is
from the Flags namespace.
Now that I think about it, does it look in the namespaces
for the formal or actual arguments?

It looks in the namespaces of the _types_ (types are determined from the
actual arguments of course). IOW, if you did

Flags::flag_typ e someflag;
foo(someflag);

it would still resolve 'foo' as 'Flags::foo' because the _type_ of the
'someflag' argument is from 'Flags' namespace.

V

[Ioannis Vranos]

REH wrote:

I'm a little confused about argument dependent lookup. Exactly when does
this apply? Specifically, I was hoping to use it to access enumeration
constants. For example:

namespace Flags {
enum flag_type {F1, F2, F3};
}

void foo(Flags::flag _type f)
{
}

int main()
{
foo(Flags::F1);
}

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[REH]

"Victor Bazarov" <v.********@com Acast.net> wrote in message
news:EO******** ***********@new sread1.mlpsca01 .us.to.verio.ne t...

Yes. The namespaces of the arguments are searched for the function names.
So, if you do

namespace Flags {
enum flag_type {F1, F2, F3};
void foo(Flags::flag _type f)
{
}
} // namespace

int main()
{
foo(Flags::F1); // no qualification for 'foo'
}

The compiler will resolve 'foo' as 'Flags::foo' because the argument is
from the Flags namespace.

Thank you. That's clear. I like to keep my enums in their own namespace,
but always typing "namespace::con stant" gets tedious. I had hoped to use
Koenig Lookup to avoid that, but from what you are telling me I can't (other
than with "using").

Regards.

[Ioannis Vranos]

REH wrote:

Thank you. That's clear. I like to keep my enums in their own namespace,
but always typing "namespace::con stant" gets tedious. I had hoped to use
Koenig Lookup to avoid that, but from what you are telling me I can't (other
than with "using").

All *names* specified in a namespace must be used with their namespace
name (either explicit namespace::name style or via using statements).


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Victor Bazarov]

Ioannis Vranos wrote:

REH wrote:

Thank you. That's clear. I like to keep my enums in their own
namespace,
but always typing "namespace::con stant" gets tedious. I had hoped to
use
Koenig Lookup to avoid that, but from what you are telling me I can't
(other
than with "using").

All *names* specified in a namespace must be used with their namespace
name (either explicit namespace::name style or via using statements).

No, that's incorrect. See my example:

namespace NS {
class foo;
void bar(foo*);
}

int main() {
NS::foo* pfoo = 0;
bar(pfoo);
}

I happily used 'bar' without a namespace. That's what ADL is all about.

V

[REH]

"Victor Bazarov" <v.********@com Acast.net> wrote in message
news:bq******** ***********@new sread1.mlpsca01 .us.to.verio.ne t...

All *names* specified in a namespace must be used with their namespace
name (either explicit namespace::name style or via using statements).

No, that's incorrect. See my example:

namespace NS {
class foo;
void bar(foo*);
}

int main() {
NS::foo* pfoo = 0;
bar(pfoo);
}

I happily used 'bar' without a namespace. That's what ADL is all about.

V

But, I take it that there is no way to do this with non-function names?

[Victor Bazarov]

REH wrote:

"Victor Bazarov" <v.********@com Acast.net> wrote in message
news:bq******** ***********@new sread1.mlpsca01 .us.to.verio.ne t...

All *names* specified in a namespace must be used with their namespace
name (either explicit namespace::name style or via using statements).

No, that's incorrect. See my example:

namespace NS {
class foo;
void bar(foo*);
}

int main() {
NS::foo* pfoo = 0;
bar(pfoo);
}

I happily used 'bar' without a namespace. That's what ADL is all about.

V

But, I take it that there is no way to do this with non-function names?

Right. _Argument_-dependent lookup applies only to function names. The
only other thing that has arguments in C++ is templates. But ADL doesn't
apply to them:

namespace NS {
enum foo { f };
template<foo f> class bar {};
}

int main() {
bar<NS::f> barf; // line 7
}

Here, on line 7, 'bar' is not going to be looked up in 'NS' even though
its _argument_ is fully qualified (and found in 'NS' namespace).

V

[Ioannis Vranos]

Victor Bazarov wrote:

No, that's incorrect. See my example:

namespace NS {
class foo;
void bar(foo*);
}

int main() {
NS::foo* pfoo = 0;
bar(pfoo);
}

I happily used 'bar' without a namespace. That's what ADL is all about.

Where is the function definition?


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Ioannis Vranos wrote:

Victor Bazarov wrote:

No, that's incorrect. See my example:

namespace NS {
class foo;
void bar(foo*);
}

int main() {
NS::foo* pfoo = 0;
bar(pfoo);
}

I happily used 'bar' without a namespace. That's what ADL is all about.

Where is the function definition?

Apart from missing function definition, this is the case of ADL (for
example bar(0); would not compile).


--
Ioannis Vranos

http://www23.brinkster.com/noicys