C ++ SFINAE运算符/函数结果类型检查

Question

I am writing a template-based class for Polynomials. (Evaluation, some operations between Polynomials, differentiation, ...), like this: template <typename _ty> class Polynomial{...

For the to_string function (and the std::ostream -left-shift-override), I had to check, if _ty supports the < -operator (ie yes for real numbers, no for complex numbers), so that the string could be formatted nicely. For this I use this code:

#include <type_traits>

template <class _op, class... _ty, typename = decltype(std::declval<_op>()(std::declval<_ty>()...))>
std::true_type impl_test(const _op&, const _ty&...) { return std::true_type(); }
std::false_type impl_test(...) { return std::false_type(); }
template <class> struct supports;
template <class _op, class... _ty> struct supports<_op(_ty...)> : decltype(impl_test(std::declval<_op>(), std::declval<_ty>()...)){};

#define is_ineq_supported(type) supports<std::less<>(type, type)>()

In short, is_ineq_supported(type) returns an std::true_type if there is a valid overload for the < -operator, and a false_type if not. The corresponding functions can then be called with a true_type or false_type as the distinguishing argument, like this:

template <typename _ty> void do_stuff(_ty arg, const std::true_type&) {
    // do stuff with the '<'-operator
}

template <typename _ty> void do_stuff(_ty arg, const std::false_type&) {
    // do stuff without the '<'-operator
}

template <typename _ty> void do_stuff(_ty arg) {
    do_stuff(arg, is_ineq_supported(_ty));
}

I also have a Vector class, that overloads the binary * -operator with the dot product, so it returns a double . But for a polynomial, it only makes sense, to have coefficients and arguments, which return the same type when multiplied with one another.

I'd like to have a way of checking, if the given operation returns a specified type. (maybe a similar macro?) I think, the simplest would be something that returns a true_type if the result type matches the argument type and a false_type otherwise. Of course, more general solutions are even better.

In case, the IDE and Compiler matter: I'm using Visual Studio 2015 with default settings.

Answer 1

Here is a generic, cross-platform solution using fit::is_callable , which will be eventually added to Boost. Also keep your eye out for std::is_callable in C++17.

No macros necessary:

#include <type_traits>
#include <iostream>
#include <fit/is_callable.hpp>

// std::less doesn't SFINAE, so we make our own test
struct less_test {
    template<typename L, typename R>
    auto operator()(L l, R r) -> decltype(l < r);
};

template<typename T>
using is_less_than_comparable = fit::is_callable<less_test, T, T>;

// operator< version (replace with your implementation)
template <typename T> constexpr auto
do_stuff(T arg, const std::true_type&) {
    return std::integral_constant<int, 0>{};
}

// other version (replace with your implementation)
template <typename T> constexpr auto
do_stuff(T arg, const std::false_type&) {
    return std::integral_constant<int, 1>{};
}

template <typename T> constexpr auto
do_stuff(T arg) {
    return do_stuff(arg, is_less_than_comparable<T>{});
}

struct foo {};

int main() {

    //is not less-than comparable
    static_assert(do_stuff(foo{}) == 1, "");

    //is less-than comparable
    static_assert(do_stuff(0) == 0, "");
}

Answer 2

You should probably reconsider your member method detectors and use the most C++11-ish void_t based solution.

That said, if I had to update your solution, probably the following code is a viable approach:

template <class _op, class _ret, class... _ty>
typename std::enable_if<std::is_same<decltype(std::declval<_op>()(std::declval<_ty>()...)), _ret>::value, std::true_type>::type
impl_test(const _op&, const _ty&...) {
    return std::true_type();
}

This will work as it follows:

struct S { int operator()() { return 42; } };

int main() {
    assert((impl_test<S, int>(S{})));
    // this will give you an error at compile time
    // assert((impl_test<S, double>(S{})));
}