通过使用指令调用开始和结束？

既定的调用习惯用法swap is:

using std::swap
swap(foo, bar);

这边走，swap可以对外部的用户定义类型进行重载std命名空间。

我们应该调用begin and end以同样的方式？

using std::begin;
using std::end;
some_algorithm(begin(some_container), end(some_container));

或者我们应该这样写：

some_algorithm(std::begin(some_container), std::end(some_container));

Using a using-宣言IMO 就是这样。这也是标准对 for 循环范围所做的操作：如果没有begin or end出席的成员然后它会打电话begin(x) and end(x) with std作为关联的命名空间（即它会发现std::begin and std::end如果 ADL 未找到非会员begin and end).

如果你发现这样写using std::begin; using std::end;一直很乏味，那么你可以使用adl_begin and adl_end功能如下：

namespace aux {

using std::begin;
using std::end;

template<class T>
auto adl_begin(T&& x) -> decltype(begin(std::forward<T>(x)));

template<class T>
auto adl_end(T&& x) -> decltype(end(std::forward<T>(x)));

template<class T>
constexpr bool is_array()
{
    using type = typename std::remove_reference<T>::type;
    return std::is_array<type>::value;
}

} // namespace aux

template<class T,
         class = typename std::enable_if<!aux::is_array<T>()>::type>
auto adl_begin(T&& x) -> decltype(aux::adl_begin(std::forward<T>(x)))
{
    using std::begin;
    return begin(std::forward<T>(x));
}

template<class T,
         class = typename std::enable_if<!aux::is_array<T>()>::type>
auto adl_end(T&& x) -> decltype(aux::adl_end(std::forward<T>(x)))
{
    using std::end;
    return end(std::forward<T>(x));
}

template<typename T, std::size_t N>
T* adl_begin(T (&x)[N])
{
    return std::begin(x);
}

template<typename T, std::size_t N>
T* adl_end(T (&x)[N])
{
    return std::end(x);
}

这段代码非常可怕。希望在 C++14 中这可以变得不那么神秘：

template<typename T>
concept bool Not_array()
{
    using type = std::remove_reference_t<T>;
    return !std::is_array<type>::value;
}

decltype(auto) adl_begin(Not_array&& x)
{
    using std::begin;
    return begin(std::forward<Not_array>(x));
}

decltype(auto) adl_end(Not_array&& x)
{
    using std::end;
    return end(std::forward<Not_array>(x));
}

template<typename T, std::size_t N>
T* adl_begin(T (&x)[N])
{
    return std::begin(x);
}

template<typename T, std::size_t N>
T* adl_end(T (&x)[N])
{
    return std::end(x);
}