检测操作者支持与decltype/SFINAE

Question

A（稍微）过时article探索的方式来使用decltype与SFINAE沿检测是否一种类型的支持特定运营商，如==或<。

这里的示例代码来检测一个类支持<操作者：

template <class T> 
struct supports_less_than 
{ 
    static auto less_than_test(const T* t) -> decltype(*t < *t, char(0)) 
    { } 

    static std::array<char, 2> less_than_test(...) { } 

    static const bool value = (sizeof(less_than_test((T*)0)) == 1); 
}; 

int main() 
{ 
    std::cout << std::boolalpha << supports_less_than<std::string>::value << endl; 
} 

此输出true，由于当然std::string支持<运算符。但是，如果我尝试了一类使用而不支持<运营商，我得到一个编译错误：

error: no match for ‘operator<’ in ‘* t < * t’ 

所以SFINAE不能在这里工作。我在GCC 4.4和GCC 4.6上试了这个，并且都表现出相同的行为。那么，是否有可能以这种方式使用SFINAE来检测某种类型是否支持某些表达式？

Answer 1

你需要让你的less_than_test功能的模板，因为SFINAE代表换人失败不是一种错误，而且也没有能在你的代码无法选择模板功能。

template <class T> 
struct supports_less_than 
{ 
    template <class U> 
    static auto less_than_test(const U* u) -> decltype(*u < *u, char(0)) 
    { } 

    static std::array<char, 2> less_than_test(...) { } 

    static const bool value = (sizeof(less_than_test((T*)0)) == 1); 
}; 

int main() 
{ 
    std::cout << std::boolalpha << supports_less_than<std::string>::value << endl; 
} 

Answer 2

下面简单的代码，满足您的要求（如果你不想编译错误）：

namespace supports { 
    template<typename T> // used if T doesn't have "operator <" associated 
    const long long operator < (const T&, const T&); 

    template <class T> 
    struct less_than { 
    T t; 
    static const bool value = (sizeof(t < t) != sizeof(long long)); 
    }; 
} 

用法：

supports::less_than<std::string>::value ====> true; // ok 
supports::less_than<Other>::value ====> false; // ok: no error 

[注：如果你想编译类错误没有比operator <这是非常容易的代码非常几行产生。]

Answer 3

@xDD确实是正确的，虽然他的例子有些错误。

本汇编了ideone：

true 
false 

见行动it here：

#include <array> 
#include <iostream> 

struct Support {}; bool operator<(Support,Support) { return false; } 
struct DoesNotSupport{}; 

template <class T> 
struct supports_less_than 
{ 
    template <typename U> 
    static auto less_than_test(const U* u) -> decltype(*u < *u, char(0)) 
    { } 

    static std::array<char, 2> less_than_test(...) { } 

    static const bool value = (sizeof(less_than_test((T*)0)) == 1); 
}; 

int main() 
{ 
    std::cout << std::boolalpha << supports_less_than<Support>::value << std::endl; 
    std::cout << std::boolalpha << 
    supports_less_than<DoesNotSupport>::value << std::endl; 
} 

在

和结果。

的一点是，SFINAE仅应用于模板功能。

Answer 4

这是C++ 0x中，我们不需要sizeof为基础的技巧更多...; - ]

#include <type_traits> 
#include <utility> 

namespace supports 
{ 
    namespace details 
    { 
     struct return_t { }; 
    } 

    template<typename T> 
    details::return_t operator <(T const&, T const&); 

    template<typename T> 
    struct less_than : std::integral_constant< 
     bool, 
     !std::is_same< 
      decltype(std::declval<T const&>() < std::declval<T const&>()), 
      details::return_t 
     >::value 
    > { }; 
} 

（这是基于iammilind的回答，但不要求T的operator<返回类型是不同的大小比long long和不需要T是默认施工的。）

Answer 5

在C++ 11我发现最短，最一般的解决方案是这一个：

#include <type_traits> 

template<class T, class = decltype(std::declval<T>() < std::declval<T>())> 
std::true_type supports_less_than_test(const T&); 
std::false_type supports_less_than_test(...); 

template<class T> using supports_less_than = decltype(supports_less_than_test(std::declval<T>())); 

#include<iostream> 
struct random_type{}; 
int main(){ 
    std::cout << supports_less_than<double>::value << std::endl; // prints '1' 
    std::cout << supports_less_than<int>::value << std::endl; // prints '1' 
    std::cout << supports_less_than<random_type>::value << std::endl; // prints '0' 
} 

作品与g++ 4.8.1和clang++ 3.3

---

任意操作者A更通用的解决方案（UPDATE 2014）

有一个更通用的解决方案，利用所有buil t-in操作符也可以通过STD操作符包装（如std::less（二进制）或std::negate（一元））访问（并且可以专用）。

template<class F, class... T, typename = decltype(std::declval<F>()(std::declval<T>()...))> 
std::true_type supports_test(const F&, const T&...); 
std::false_type supports_test(...); 

template<class> struct supports; 
template<class F, class... T> struct supports<F(T...)> 
: decltype(supports_test(std::declval<F>(), std::declval<T>()...)){}; 

这可以以相当普遍的方式来使用，特别是在C++ 14，其中型扣被延迟给操作者包装呼叫（“透明运营商”）。

对于二进制运算符它可以用作：

#include<iostream> 
struct random_type{}; 
int main(){ 
    std::cout << supports<std::less<>(double, double)>::value << std::endl; // '1' 
    std::cout << supports<std::less<>(int, int)>::value << std::endl; // '1' 
    std::cout << supports<std::less<>(random_type, random_type)>::value << std::endl; // '0' 
} 

对于一元运算符：

#include<iostream> 
struct random_type{}; 
int main(){ 
    std::cout << supports<std::negate<>(double)>::value << std::endl; // '1' 
    std::cout << supports<std::negate<>(int)>::value << std::endl; // '1' 
    std::cout << supports<std::negate<>(random_type)>::value << std::endl; // '0' 
} 

（用C++ 11标准库是有点复杂，因为没有失败即使没有为random_type定义操作，也可以实现decltype(std::less<random_type>()(...))，但是可以在C++ 11中实现手动透明运算符，这些运算符在C++ 14中是标准的）

语法非常流畅。我希望标准中采用这样的东西。

---

两个扩展：

1）它的工作原理，以检测原始功能的应用：

struct random_type{}; 
random_type fun(random_type x){return x;} 
int main(){ 
    std::cout << supports<decltype(&fun)(double)>::value << std::endl; // '0' 
    std::cout << supports<decltype(&fun)(int)>::value << std::endl; // '0' 
    std::cout << supports<decltype(&fun)(random_type)>::value << std::endl; // '1' 
} 

2）它可以另外地检测如果结果是可兑换/可比到一定类型，在这种情况下，支持double < double，但由于结果不是指定的，因此将返回编译时false。

std::cout << supports<std::equal_to<>(std::result_of<std::less<>(double, double)>::type, random_type)>::value << std::endl; // '0' 

注：我只是试图编译C++ 14的代码http://melpon.org/wandbox/并没有奏效。我认为在该实现中（clang ++ 3.5 C++ 14）透明运算符（如std::less<>）存在问题，因为当我实现自己的less<>并自动扣除时，它运行良好。