argument-dependent-lookup

There are 3 examples: I. typedef int foo; namespace B { struct S { operator int(){ return 24; } }; int foo(B::S s){ return 0; } } int main() { int t=foo(B::S()); //24, ADL does not apply } II. namespace B { struct S { operator int(){ return 24; } }; int foo(B::S s){ return 0; } } int main() { int t=foo(B::S()); //0, ADL applies } III. namespace B { struct S { operator int(){ return 24; } }; int foo(B::S s){ return 0; } } int foo(B::S s){ return 12; } int main() { int t=foo(B::S()); //error: call of overloaded ‘foo(B::S)’ is ambiguous //ADL applies } It is not clear for me what is the actual

The C++0x standard working draft states (section 6.5.4) the following about the begin() and end() calls that are implicit in a range-based for loop: 'begin' and 'end' are looked up with argument-dependent lookup (3.4.2). For the purposes of this name lookup, namespace std is an associated namespace. The way I read this, this means that the overload resolution set for the calls to begin() and end() includes all of the following: all overloads of begin() and end() that are in scope at the location where the range-based for loop is used (in particular, all overloads in the global namespace will

Considering: #include <cassert> #include <boost/range/irange.hpp> #include <boost/range/algorithm.hpp> int main() { auto range = boost::irange(1, 4); assert(boost::find(range, 4) == end(range)); } Live Clang demo Live GCC demo this gives: main.cpp:8:37: error: use of undeclared identifier 'end' Considering that if you write using boost::end; it works just fine , which implies that boost::end is visible: Why is ADL not working and finding boost::end in the expression end(range) ? And if it's intentional, what's the rationale behind it? To be clear, the expected result would be similar to what

After this question by utilizing ADL one can create a trait to answer if the passed type comes from our namespace: #include <utility> namespace helper { template <typename T, typename = void> struct is_member_of_sample : std::false_type { }; template <typename T> struct is_member_of_sample< T, decltype(adl_is_member_of_sample(std::declval<T>()))> : std::true_type { }; } namespace sample { template <typename T> auto adl_is_member_of_sample(T && ) -> void; } // -- Test it namespace sample { struct X; } struct Y; static_assert(helper::is_member_of_sample<sample::X>::value, ""); static_assert(not

Consider a legacy class template with overloaded addition operators += and + template<class T> class X { public: X() = default; /* implicict */ X(T v): val(v) {} X<T>& operator+=(X<T> const& rhs) { val += rhs.val; return *this; } X<T> operator+ (X<T> const& rhs) const { return X<T>(*this) += rhs; } private: T val; }; Upon code review, it is observed that + is implementable in terms of += , so why not make it a non-member (and have guaranteed symmetry for left and right arguments)? template<class T> class X { public: X() = default; /* implicit */ X(T v): val(v) {} X<T>& operator+=(X<T> const&