通过使用指令调用begin和end？

Question

调用swap的惯用法是：

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

这样，就可以为std命名空间之外的用户定义类型重载交换。

我们是否应该以相同的方式调用开始和结束？

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

或者我们应该写：

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

Answer 1

如果some\u容器是标准容器，则不需要std：：prefix

#include <iostream>
#include <vector>
#include <algorithm>
int main(){ 
       std::vector<int>v { 1, 7, 1, 3, 6, 7 };
       std::sort( begin(v), end(v) ); // here ADL search finds std::begin, std::end
}

Answer 2

匿名用户

免责声明：对于学究类型（或者学究，如果你想学究的话…），在这里，我通常将“重载”一词称为“创建名称为begin和end的函数，并且使用std：：begin；使用std：：end；”，相信我，这本书对我来说一点也不乏味，但读起来很难，读起来很多余<代码>：p.

我基本上会给你这种技术的可能用例，以及我的结论。

您可能需要重载std::begin和std::end函数的一种情况是，当您以不同的方式使用类型的开始和end方法时，而不是提供对对象元素的类似迭代器的访问，并且希望重载std::begin和std::end调用用于迭代的开始和结束方法。

struct weird_container {
   void begin() { std::cout << "Start annoying user." }
   void end() { std::cout << "Stop annoying user." }

   iterator iter_begin() { /* return begin iterator */ }
   iterator iter_end() { /* return end iterator */ }
};


auto begin(weird_container& c) {
   return c.iter_begin();
}

auto end(weird_container& c) {
   return c.iter_end();
}

但是，如果将range for与weird\u container的对象一起使用，您不会也不应该做这样疯狂的事情，因为根据range for的规则，在独立函数变体之前会找到weird\u container：：begin（）和weird\u container：：end（）方法。

因此，这个案例提出了一个论点，即不要使用您提出的内容，因为这会破坏语言的一个非常有用的特性。

另一种情况是当您没有定义开始和结束方法时。这是一个更常见和适用的情况，当您想在不修改类接口的情况下扩展您的类型以使其可迭代时。

struct good_ol_type {
   ...
   some_container& get_data();
   ...
};

auto begin(good_ol_type& x) {
   return x.get_data().begin();
}

auto end(good_ol_type& x) {
   return x.get_data().end();
}

这将使您能够在good_ol_type（算法、范围等）上使用一些漂亮的特性，而无需实际修改其界面！这符合Herb Sutter关于通过非成员非朋友函数扩展类型功能的建议。

这是一个很好的例子，您实际上想要重载std：；开始和结束。

因为我从未见过有人做过像第一个案例那样的事情（我的例子除外），所以您真的希望使用您所建议的内容，并在适用的情况下重载std：：begin和std：：end。

这里我没有包括这样一种情况，即您定义了开始和结束方法，以及开始和结束函数，这些函数的作用与方法不同。我相信这样的情况是人为的、格式错误的和/或由一个程序员造成的，他没有太多深入研究调试器或阅读新模板错误的经验。

Answer 3

使用这样的使用-声明是IMO的正确方式。这也是标准对循环范围的作用：如果没有开始或结束成员存在，那么它将调用开始（x）和结束（x），std作为关联的命名空间（即如果ADL没有找到非成员开始和结束，它将找到std::begin和std::end）。

如果您发现使用std：：begin编写；使用std：：end 一直都很乏味，然后您可以使用下面的adl\U开始和adl\U结束功能：

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);
}