What are the pitfalls of ADL?

Question

Some time ago I read an article that explained several pitfalls of argument dependent lookup, but I cannot find it anymore. It was about gaining access to things that you should not have access to or something like that. So I thought I'd ask here: what are the pitfalls of ADL?

Answer 1

From Wikipedia (http://en.wikipedia.org/wiki/Argument_dependent_name_lookup):

While ADL makes it practical for free functions to be part of the interface of a class, it makes namespaces less strict and so can require the use of fully-qualified names when they would not otherwise be needed. For example, the C++ standard library makes extensive use of unqualified calls to std::swap to swap two values. The idea being that then one can define an own version of std::swap in one's own namespace and it will be used within the STL algorithms. In other words, the behavior of

std::swap(a, b);

may or may not be the same as the behavior of

using std::swap;
swap(a, b);

(where a and b are of type N::A) because if N::swap(N::A&, N::A&) exists, the second of the above examples call it while the first will not. Furthermore, if for some reason both N::swap(N::A&, N::A&) and std::swap(N::A&, N::A&) are defined, then the first example will call std::swap(N::A&, N::A&) but the second will not compile because swap(a, b) would be ambiguous.

In general, over-dependence on ADL can lead to semantic problems. If one library, L1, expects unqualified calls to foo(T) to have one meaning and another library, L2 expects it to have another, then namespaces lose their utility. If, however, L1 expects L1::foo(T) to have one meaning and L2 does likewise, then there is no conflict, but calls to foo(T) would have to be fully qualified (as opposed to using L1::foo; foo(x);) lest ADL get in the way.