ADL without templates

Question

Can one show me an example of ADL without using templates? Never seen something like that. I mean something like here. Specifically I am interested in example in which it leads to some pitfall like in mentioned.

EDIT:

I think Tomalak's answer can be extended to pitfall. Consider this:

namespace dupa {

    class A {
    };

    class B : public A {
    public:
        int c;
        B() {
        }
    };

   void f(B b) {
       printf("f from dupa called\n");
   }
}

void f(dupa::A) {
    printf("f from unnamed namespace called\n");
}


int main()
{   
    dupa::B b;
    f(b);

    return 0;
}

Here we expect that f from unnamed namespace will be called, but instead another one is called.

Yea, and [why doesn't this work](http://codepad.org/IGg4jf2X)? — Lightness Races in Orbit, Jul 13 '11 at 21:00
@Tomalak Because the type of `lol` is `int`. [See this.](http://codepad.org/bol4Enag) — Luc Danton, Jul 13 '11 at 21:02
I do suggest you change namespace name, someone may be offended by it. — Tomek, Jul 14 '11 at 07:34
@Tomek: `dupa` is polish equivalent of English `foo` - who could be offended by that if almost everyone uses that? ;-) — Pawel Zubrycki, Apr 04 '12 at 13:32

score 4 · Accepted Answer · answered Jul 13 '11 at 21:05

I can't show you something leading to a pitfall, but I can demonstrate ADL working without templates:

namespace foo {
   struct T {} lol;
   void f(T) {}
}

int main() {
   f(foo::lol);
}

Note that lol's type has to be a class-type; I originally tried with a built-in, as you saw, and it didn't work.

score 2 · Answer 2 · answered Jul 13 '11 at 21:40

The trick to get confusion is creating an scenario where the arguments to the function are interchangeable or convertible and that ADL might pick something that might not be what you would expect. I am not sure if this is impressive or just expected:

namespace a {
   struct A {};
   void f( A* ) { std::cout << "a::f" << std::endl; }
}
namespace b {
   struct B : ::a::A {};
   void f( B* ) { std::cout << "b::f" << std::endl; }
}

void test() {
   f( new b::B );     // b::f
   a::A* p = new b::B; 
   f( p );            // a::f
}

The types are the same, but ADL will check the static type of the argument and add that namespace into the search. That in turn means that the exact static type might make different functions visible to the compiler. Things can be more confusing when there are more than one argument on which ADL or overload resolution can apply .

Note that the effect is exactly the same of having non-virtual methods: the static type determines which of the methods is used in overloading, and that is by design: ADL is in the language so that free functions can be used as extensions to a type in a way *similar* to member functions. — David Rodríguez - dribeas, Jul 13 '11 at 22:07

score 2 · Answer 3 · answered Jul 13 '11 at 21:58

No templates.
Using swap() because that is the most common usage.

#include <iostream>

namespace One
{
    class A {};
    void swap(A& lhs, A& rhs) { std::cout << "Swap-One A\n";}
}

namespace Two
{
    class A {};
    void swap(A& lhs, A& rhs) { std::cout << "Swap-Two A\n";}
}


int main()
{
    One::A      oneA_l;
    One::A      oneA_r;
    Two::A      twoA_l;
    Two::A      twoA_r;

    swap(oneA_l, oneA_r);
    swap(twoA_l, twoA_r);
}

ADL without templates

3 Answers3