argument-dependent-lookup

Why was argument dependent lookup (ADL) invented? Is it just so we can write cout << stuff instead of std::operator<<(cout, stuff) ? If that is the case, why wasn't ADL limited to operators instead of all functions? Could the introduction of ADL have been prevented if C++ had had some other way to do generic output of both built-in and user-defined types, for example a type-safe printf via variadic templates? ADL was invented to allow the Interface Principle: The Interface Principle For a class X, all functions, including free functions, that both "mention" X, and are "supplied with" X are

I was just wondering, why would anybody write this: std::iter_swap(i, k); instead of this? std::swap(*i, *k); // saved a few keystrokes! Then I looked into the implementation of iter_swap , and of course it only uses swap instead of std::swap since we're already in namespace std , anyway. That leads me to the next question: Why would anybody write this: using std::swap; swap(a, b); instead of this? std::iter_swap(&a, &b); // saved an entire line of code! Are there any important differences/issues I am overlooking here? From the SGI docs ( here ): [1] Strictly speaking, iter_swap is redundant.

How should this code behave? It calls generic function ignoring my overload if I use qualified name in call_read() function; and it calls overload first and then generic version if I use unqualified name. What's the difference? Is it a bug in GCC? #include <iostream> struct info1 {}; struct info2 {}; template<class T> void read(T& x) { std::cout << "generic" << std::endl; } template<class T> void call_read(T& x) { ::read(x); // if I replace ::read(x) with read(x) the overload is called } void read(info1& x) { std::cout << "overload" << std::endl; } int main() { info1 x; info2 y; call_read(x);

I'm not sure if this has anything to do with sfinae, or just something thats relevant for any templated function. I am attempting to use sfinae to enable/disable a member function based on existence of corresponding free function, which in turn is enabled/disabled based on existance of member function in another type, all using method described here : struct S; template <typename T> inline auto f(S& s, T const& t) -> decltype(t.f(s), void()) { t.f(s); } struct S { template <typename T> auto f(T const& t) -> decltype(f(*this, t), void()) { f(*this, t); // <--------------------------------------

I was trying to learn and adopt the copy-swap idiom following this thorough explanation on this question: the Copy-Swap Idiom . But I found some code I had never seen: using std::swap; // allow ADL in this example class dumb_array { public: // ... void swap(dumb_array& pOther) // nothrow { using std::swap; // allow ADL /* <===== THE LINE I DONT UNDERSTAND */ swap(mSize, pOther.mSize); // with the internal members swapped, swap(mArray, pOther.mArray); // *this and pOther are effectively swapped } }; what does using std::swap; mean inside the body of a function implementation ? what does ADL