模拟基于范围的 for 循环的开始/结束行为

考虑基于范围的 for 循环的规范开始表达式 and end-expr（N4140 [stmt.ranged]/p1）。给定一个范围__range类型的_RangeT,

开始表达式 and end-expr确定如下：

• if _RangeT是一个数组类型，开始表达式 and end-expr are __range and __range + __bound，分别是，其中__bound是 数组绑定。如果_RangeT是一个未知大小的数组或一个数组 不完整类型，程序格式不正确；
• if _RangeT是一个类类型，不合格的 IDs begin and end在类范围内查找_RangeT就像通过类成员访问一样 查找（3.4.5），并且如果其中一个（或两者）找到至少一个 宣言，开始表达式 and end-expr are __range.begin() and __range.end()， 分别;
• 否则，开始表达式 and end-expr are begin(__range) and end(__range)，分别是，其中begin and end被查找于 关联的命名空间 (3.4.2)。 [Note：普通不合格 不执行查找（3.4.1）。 —end note ]

是否可以模拟这个exact普通 C++ 代码中的行为？即，我们可以写一个magic_begin and a magic_end函数模板使得

for(auto&& p : range_init) { /* statements */ }

and

{
    auto&& my_range = range_init;
    for(auto b = magic_begin(my_range), e = magic_end(my_range); b != e; ++b){
        auto&& p = *b;
        /* statements */
    }
}

总是有完全相同的行为？

无应答包括合格的呼叫std::begin/std::end（不处理第三个项目符号等）并且using std::begin; begin(range);因为除其他外，如果 ADL 为begin找到一个同样好的重载std::begin.

为了便于说明，给出

namespace foo {
    struct A { int begin; }; 
    struct B { using end = int; };
    class C { int* begin(); int *end(); }; // inaccessible
    struct D { int* begin(int); int* end();};
    struct E {};

    template<class T> int* begin(T&) { return nullptr; }
    template<class T> int* end(T&) { return nullptr; }
}

foo::A a; foo::B b; foo::C c; foo::D d; foo::E e;

I want magic_begin(a)/magic_begin(b)/magic_begin(c)/magic_begin(d)是一个编译错误，并且magic_begin(e)回来(int*)nullptr.

以下 SFINAE 友好方法似乎可以按预期工作（有关例外情况，请参见下文）：

#include <type_traits>

namespace detail {
    struct empty {};
    template <typename T>
    using base = std::conditional_t<std::is_class<T>{} && not std::is_final<T>{},
                                    T, empty>;

    struct P1 {typedef int begin, end;};
    template <typename U>
    struct TestMemType : base<U>, P1 {
        template <typename T=TestMemType, typename=typename T::begin>
        static std::true_type test_begin(int);
        template <typename T=TestMemType, typename=typename T::end>
        static std::true_type test_end(int);

        static std::false_type test_begin(float), test_end(float);
    };

    template <typename T>
    constexpr bool hasMember = !decltype(TestMemType<T>::test_begin(0)){}
                            || !decltype(TestMemType<T>::test_end(0)){};

    //! Step 1
    template <typename T, std::size_t N>
    constexpr auto begin(int, T(&a)[N]) {return a;}
    template <typename T, std::size_t N>
    constexpr auto end(int, T(&a)[N]) {return a+N;}

    //! Step 2 - this overload is less specialized than the above.
    template <typename T>
    constexpr auto begin(int, T& a) -> decltype(a.begin()) {return a.begin();}
    template <typename T>
    constexpr auto end(int, T& a) -> decltype(a.end()) {return a.end();}

    //! Step 3
    namespace nested_detail {
        void begin(), end();
        template <typename T>
        constexpr auto begin_(T& a) -> decltype(begin(a)) {return begin(a);}
        template <typename T>
        constexpr auto end_(T& a) -> decltype(end(a)) {return end(a);}
    }
    template <typename T, typename=std::enable_if_t<not hasMember<std::decay_t<T>>>>
    constexpr auto begin(float, T& a) -> decltype(nested_detail::begin_(a))
    {return nested_detail::begin_(a);}
    template <typename T, typename=std::enable_if_t<not hasMember<std::decay_t<T>>>>
    constexpr auto end(float, T& a) -> decltype(nested_detail::end_(a))
    {return nested_detail::end_(a);}
}

template <typename T>
constexpr auto magic_begin(T& a) -> decltype(detail::begin(0, a))
{return detail::begin(0, a);}
template <typename T>
constexpr auto magic_end  (T& a) -> decltype(detail::end  (0, a))
{return detail::  end(0, a);}

Demo http://coliru.stacked-crooked.com/a/3c8514f56c017396。请注意，GCC 查找已损坏，因为它不考虑非类型名称typename T::begin in TestMemType::test_end/begin。可以找到解决方法草图here http://coliru.stacked-crooked.com/a/8abb2f9761f4ea34.

步骤 2 中的检查要求类类型是可派生的，这意味着该方法不能正确使用final类或联合 - 如果它们具有无法访问的成员名称begin/end.