Question

在this answer中，我根据类型的is_arithmetic属性定义模板：

template<typename T> enable_if_t<is_arithmetic<T>::value, string> stringify(T t){
    return to_string(t);
}
template<typename T> enable_if_t<!is_arithmetic<T>::value, string> stringify(T t){
    return static_cast<ostringstream&>(ostringstream() << t).str();
}

dyp suggests而不是该类型的is_arithmetic属性，是否为该类型定义to_string是模板选择标准。这显然是可取的，但我不知道如何说：

如果未定义std::to_string，请使用ostringstream重载。

声明to_string条件很简单：

template<typename T> decltype(to_string(T{})) stringify(T t){
    return to_string(t);
}

这与我无法弄清楚如何构建的标准相反。这显然不起作用，但希望它传达了我正在努力构建的内容：

template<typename T> enable_if_t<!decltype(to_string(T{})::value, string> (T t){
    return static_cast<ostringstream&>(ostringstream() << t).str();
}

Answer 1

使用Walter Brown's void_t：

template <typename...>
using void_t = void;

很容易做出这样的特质：

template<typename T, typename = void>
struct has_to_string
: std::false_type { };

template<typename T>
struct has_to_string<T, 
    void_t<decltype(std::to_string(std::declval<T>()))>
    > 
: std::true_type { };

Answer 2

首先，我认为SFINAE通常应该从接口隐藏。它使界面混乱。将SFINAE放在远离水面的位置，并使用标签调度来选择过载。

其次，我甚至将SFINAE隐藏在特质类中。在我的经验中写“我可以做X”代码是很常见的，我不想编写凌乱的SFINAE代码来完成它。因此，我写了一个通用的can_apply特征，并且如果使用decltype传递错误的类型，则具有SFINAE失败的特征。

然后我们将SFIANE失败的decltype特征提供给can_apply，并根据应用程序是否失败来获取真/假类型。

这将每个“我可以做X”特性的工作量减少到最低限度，并将有些棘手和脆弱的SFINAE代码放在日常工作之外。

我使用C ++ 1z的void_t。自己实现它很容易（在这个答案的底部）。

类似于can_apply的元函数被提议用于C ++ 1z中的标准化，但它不像void_t那样稳定，所以我没有使用它。

首先，details命名空间隐藏can_apply的实现，使其无法被发现：

namespace details {
  template<template<class...>class Z, class, class...>
  struct can_apply:std::false_type{};
  template<template<class...>class Z, class...Ts>
  struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...>:
    std::true_type{};
}

然后我们可以用can_apply来编写details::can_apply，它有一个更好的界面（它不需要传递额外的void）：

template<template<class...>class Z, class...Ts>
using can_apply=details::can_apply<Z, void, Ts...>;

以上是通用辅助元编程代码。一旦我们完成它，我们就可以非常干净地编写一个can_to_string特征类：

template<class T>
using to_string_t = decltype( std::to_string( std::declval<T>() ) );

template<class T>
using can_to_string = can_apply< to_string_t, T >;

我们有一个特征can_to_string<T>如果我们可以to_string一个T，那就是真的。

这项工作需要编写一个新的特性，现在是2-4行简单代码 - 只需创建一个decltype using别名，然后进行can_apply测试它

一旦我们有了这个，我们就会使用标签调度来实现正确的实现：

template<typename T>
std::string stringify(T t, std::true_type /*can to string*/){
  return std::to_string(t);
}
template<typename T>
std::string stringify(T t, std::false_type /*cannot to string*/){
  return static_cast<ostringstream&>(ostringstream() << t).str();
}
template<typename T>
std::string stringify(T t){
  return stringify(t, can_to_string<T>{});
}

所有丑陋的代码都隐藏在details命名空间中。

如果您需要void_t，请使用：

template<class...>struct voider{using type=void;};
template<class...Ts>using void_t=typename voider<Ts...>::type;

适用于大多数主要的C ++ 11编译器。

请注意，较简单的template<class...>using void_t=void;无法在一些较旧的C ++ 11编译器中工作（标准中存在歧义）。

Answer 3

在上周的委员会会议上刚刚投票进入图书馆基础TS：

template<class T>
using to_string_t = decltype(std::to_string(std::declval<T>()));

template<class T>
using has_to_string = std::experimental::is_detected<to_string_t, T>;

然后将has_to_string上的调度和/或SFINAE标记到您心中的内容。

您可以就is_detected和朋友的实施方式咨询the current working draft of the TS。它与@ Yakk的答案中的can_apply非常相似。

Answer 4

您可以使用表达式SFINAE编写一个辅助特征：

namespace detail
{
    //base case, to_string is invalid
    template <typename T>
    auto has_to_string_helper (...) //... to disambiguate call
       -> false_type;

    //true case, to_string valid for T
    template <typename T>
    auto has_to_string_helper (int) //int to disambiguate call
       -> decltype(std::to_string(std::declval<T>()), true_type{});
}

//alias to make it nice to use
template <typename T>
using has_to_string = decltype(detail::has_to_string_helper<T>(0));

然后使用std::enable_if_t<has_to_string<T>::value>

Demo

Answer 5

我认为有两个问题：1）找到给定类型的所有可行算法。 2）选择最好的一个。

例如，我们可以手动指定一组重载算法的顺序：

namespace detail
{
    template<typename T, REQUIRES(helper::has_to_string(T))>
    std::string stringify(choice<0>, T&& t)
    {
        using std::to_string;
        return to_string(std::forward<T>(t));
    }

    template<std::size_t N>
    std::string stringify(choice<1>, char const(&arr)[N])
    {
        return std::string(arr, N);
    }

    template<typename T, REQUIRES(helper::has_output_operator(T))>
    std::string stringify(choice<2>, T&& t)
    {
        std::ostringstream o;
        o << std::forward<T>(t);
        return std::move(o).str();
    }
}

第一个函数参数指定这些算法之间的顺序（＆＃34;第一选择＆＃34;，＆＃34;第二选择＆＃34;，..）。为了选择算法，我们只需调度到最佳可行匹配：

template<typename T>
auto stringify(T&& t)
    -> decltype( detail::stringify(choice<0>{}, std::forward<T>(t)) )
{
    return detail::stringify(choice<0>{}, std::forward<T>(t));
}

这是如何实施的？我们从Xeo @ Flaming Dangerzone和Paul @ void_t "can implement concepts"?（使用简化的实现）偷了一点：

constexpr static std::size_t choice_max = 10;
template<std::size_t N> struct choice : choice<N+1>
{
    static_assert(N < choice_max, "");
};
template<> struct choice<choice_max> {};


#include <type_traits>

template<typename T, typename = void> struct models : std::false_type {};
template<typename MF, typename... Args>
struct models<MF(Args...),
                decltype(MF{}.requires_(std::declval<Args>()...),
                         void())>
    : std::true_type {};

#define REQUIRES(...) std::enable_if_t<models<__VA_ARGS__>::value>* = nullptr

选择类继承了更糟糕的选择：choice<0>继承自choice<1>。因此，对于类型为choice<0>的参数，类型为choice<0>的函数参数比choice<1>更好匹配，这是一个比choice<2>更好的匹配，依此类推[over] .ics.rank] P4.4

请注意，只有当两个函数都没有更好时，更专业的 tie tie才适用。由于choice s的总顺序，我们永远不会陷入这种情况。即使多个算法可行，这也可以防止调用模糊不清。

我们定义我们的类型特征：

#include <string>
#include <sstream>
namespace helper
{
    using std::to_string;
    struct has_to_string
    {
        template<typename T>
        auto requires_(T&& t) -> decltype( to_string(std::forward<T>(t)) );
    };

    struct has_output_operator
    {
        std::ostream& ostream();

        template<typename T>
        auto requires_(T&& t) -> decltype(ostream() << std::forward<T>(t));
    };
}

使用an idea from R. Martinho Fernandes：

可以避免使用宏

template<typename T>
using requires = std::enable_if_t<models<T>::value, int>;

// exemplary application:

template<typename T, requires<helper::has_to_string(T)> = 0>
std::string stringify(choice<0>, T&& t)
{
    using std::to_string;
    return to_string(std::forward<T>(t));
}

Answer 6

好吧，你可以跳过所有元编程魔术并使用fit::conditional库中的Fit适配器：

FIT_STATIC_LAMBDA_FUNCTION(stringify) = fit::conditional(
    [](auto x) -> decltype(to_string(x))
    {
        return to_string(x);
    },
    [](auto x) -> decltype(static_cast<ostringstream&>(ostringstream() << x).str())
    {
        return static_cast<ostringstream&>(ostringstream() << x).str();
    }
);

或者更紧凑，如果你不介意宏：

FIT_STATIC_LAMBDA_FUNCTION(stringify) = fit::conditional(
    [](auto x) FIT_RETURNS(to_string(x)),
    [](auto x) FIT_RETURNS(static_cast<ostringstream&>(ostringstream() << x).str())
);

注意，我也限制了第二个函数，因此如果无法使用to_string调用该类型，也不能将其传输到ostringstream，则无法调用该函数。这有助于更好的错误消息和更好的可组合性，同时检查类型要求。

Answer 7

我的观点：普遍确定某项是否可调用而不用为每个特征都添加冗长的类型特征，或者使用实验性功能或长代码：

template<typename Callable, typename... Args, typename = decltype(declval<Callable>()(declval<Args>()...))>
std::true_type isCallableImpl(Callable, Args...) { return {}; }

std::false_type isCallableImpl(...) { return {}; }

template<typename... Args, typename Callable>
constexpr bool isCallable(Callable callable) {
    return decltype(isCallableImpl(callable, declval<Args>()...)){};
}

用法：

constexpr auto TO_STRING_TEST = [](auto in) -> decltype(std::to_string(in)) { return {}; };
constexpr bool TO_STRING_WORKS = isCallable<Input>(TO_STRING_TEST);

元编程：函数定义失败定义了一个单独的函数

7 个答案: