SFINAE和定义

Question

的顺序考虑这个简单SFINAE测试，以确定是否一个类型可以是，所述array头，其中，用于std::begin专业化被定义，包括后std::begin

#include <utility> 

    template <class T> constexpr auto 
std_begin_callable (T const*) -> decltype (std::begin (std::declval <T>()), bool()) 
{ return true; } 

    template <class> constexpr bool 
std_begin_callable (...) 
{ return false; } 

#include <array> 

static_assert (std_begin_callable <std::array <int, 3>> (0), "failed"); 

int main() {} 

注参数 SFINAE功能。断言失败。现在，如果我之前移动#include <array>，它的工作原理。 （GCC 4.8.0 20130411，铛版本3.2）

我不明白为什么。该SFINAE功能被模板，不应该他们在需要时实例化，在静态断言，列入标题定义他们测试的功能之后？

的问题是，我在SFINAE的标题是，我必须确保它包含任何其他容器头之后（这个问题没有具体联系到array头）。

Answer 1

正如Xeo说，使其工作，必须#include <iterator>中的begin适当的定义带来的。更确切地说，这个工程：

#include <iterator> 
#include <utility> 

template <class T> constexpr auto 
std_begin_callable (T const*) -> decltype (std::begin (std::declval <T>()), bool()) 
{ return true; } 

template <class> constexpr bool 
std_begin_callable (...) 
{ return false; } 

#include <array> 

static_assert (std_begin_callable <std::array <int, 3>> (0), "failed"); 

int main() {} 

现在，让我们来看看为什么原来的代码不包括<iterator>编译，但是没有得到预期的结果（除非你移动#include <array>了）。

包含<utility>间接意味着包含<initializer_list>，其定义为std::begin(std::initializer_list<T>)。因此，在此翻译单元中，名称std::begin可见。

但是，当您拨打std_begin_callable时，第一个过载被SFINAEd带走，因为可见std::begin不能接受std::array。现在

，如果您删除的<iterator>和<utility>共夹杂物（保持<array>std_begin_callable后），然后编译失败，因为编译器将不再看到std::begin或std::declval任何过载：

template <class T> constexpr auto 
std_begin_callable (T const*) -> decltype (std::begin (std::declval <T>()), bool()) 
{ return true; } // error: begin/declval is not a member of std 

template <class> constexpr bool 
std_begin_callable (...) 
{ return false; } 

#include <array> 

static_assert (std_begin_callable <std::array <int, 3>> (0), "failed"); 

int main() {} 

最后，可以复制/简化与此以前的错误行为：

namespace std { 

    void begin(); 

    template <typename T> 
    T&& declval(); 

} 

template <class T> constexpr auto 
std_begin_callable (T const*) -> decltype (std::begin (std::declval <T>()), bool()) 
{ return true; } // No compiler error here, just SFINAE. 

template <class> constexpr bool 
std_begin_callable (...) 
{ return false; } 

#include <array> 

static_assert (std_begin_callable <std::array <int, 3>> (0), "failed"); 

int main() {} 

UPD吃了：

从评论（这里和在OP）我想这是不可能解决你想要的方式头文件顺序问题。那么，让我建议的基础上，ADL一个变通方法，是接近的解决方案，以及可能（但可能没有），配不上你的使用情况：

// <your_header_file> 
#include <iterator> 
#include <utility> 

namespace detail { 

    using std::begin; 

    template <typename T, typename = decltype(begin(*((T*)0)))> 
    constexpr std::true_type std_begin_callable(int) { return std::true_type(); } 

    template <typename> 
    constexpr std::false_type std_begin_callable(long) { return std::false_type(); }; 

}; 

template <typename T> 
constexpr auto std_begin_callable() -> 
    decltype(detail::std_begin_callable<typename std::remove_reference<T>::type>(0)) { 
    return detail::std_begin_callable<typename std::remove_reference<T>::type>(0); 
} 
// </your_header_file> 

// <a_supposedly_std_header_file> 
namespace std { 
    struct foo { int begin() /* const */; }; 
    struct bar; 
    int begin(/*const*/ bar&); 

    template <typename T> struct goo; 

    template <typename T> 
    int begin(/*const*/ goo<T>&); 
} 
// </a_supposedly_std_header_file> 

// <a_3rd_party_header_file> 
namespace ns { 

    struct foo { int begin() /*const*/; }; 
    struct bar; 
    int begin(/*const*/ bar&); 

    template <typename T> struct goo; 

    template <typename T> 
    int begin(/*const*/ goo<T>&); 

} 
// </a_3rd_party_header_file> 

//<some_tests> 
static_assert (std_begin_callable</*const*/ std::foo>(), "failed"); 
static_assert (std_begin_callable</*const*/ std::bar>(), "failed"); 
static_assert (std_begin_callable</*const*/ std::goo<int>>(), "failed"); 

static_assert (std_begin_callable</*const*/ ns::foo>(), "failed"); 
static_assert (std_begin_callable</*const*/ ns::bar>(), "failed"); 
static_assert (std_begin_callable</*const*/ ns::goo<int>>(), "failed"); 
//</some_tests> 

int main() {} 

这似乎工作，但我还没有完全测试。我建议你尝试用/几种组合没有注释掉const S IN的代码。

我用*((T*)0)而不是std::declval<T>()，因为一个常量问题。要看到它，请将declval退回，然后尝试static_assert替代const ns::foo，并将ns::foo::begin退出非const。