19

介绍

我正在寻找一种将 C++ 类型特征转换为其可变参数的模式。解决问题的方法将受到赞赏，并且自动执行任务的生成编程模式将是理想的。

例子

采取以下措施：

std::is_same<T, U>::value;

我想写一个像这样工作的特征：

std::are_same<T1, T2, T3, T4>::value;

目前的方法

实现起来非常简单are_same；寻求一个通用的解决方案，我们可以为实现通用量化的任何可变特性提供一个工具：

template<template<class,class> class F, typename...Ts>
struct Univ;

template<template<class, class> class F, typename T, typename U, typename...Ts>
struct Univ<F, T, U, Ts...>
{
    static const int value = F<T, U>::value && Univ<F, U, Ts...>::value;
};

template<template<class, class> class F, typename T>
struct Univ<F, T>
{
    static const int value = 1;
};

这样例如are_same可以写成

Univ<is_same,int, int, int>::value

这可能适用于创建诸如are_classes等的are_scalars特征

概括

细微的调整可以从先前的片段中给出存在量化&&（替换为||），以便我们exist_same以以下方式创建特征：

Exist<is_same, int, double, float>::value

问题

上一篇关于类型特征的概括

  • 主要类型类别
  • 复合类型类别
  • 类型属性
  • 支持的操作

我将如何概括如下类型特征：

    enable_if -> enable_if_any // enable if any clause is true
                 enable_if_all // enalbe if all clauses are true
                 enable_for    // enable only for the type provided

上面的exist_same例子过于简单了。任何正确实施的想法？

有 type_traits可以“返回”修改后的类型。有什么建议可以将它们扩展到任意数量类型的实现吗？

是否有 type_traits不能扩展到任意数量的类型参数？

4

3 回答 3

24

我不完全理解您到底想要达到什么目标，但以下助手可能有用，从以下开始bool_sequence：

#include <type_traits>

// Note: std::integer_sequence is C++14,
// but it's easy to use your own version (even stripped down)
// for the following purpose:
template< bool... Bs >
using bool_sequence = std::integer_sequence< bool, Bs... >;

// Alternatively, not using C++14:
template< bool... > struct bool_sequence {};

接下来，您可以检查是否所有或任何布尔值或设置这些：

template< bool... Bs >
using bool_and = std::is_same< bool_sequence< Bs... >,
                               bool_sequence< ( Bs || true )... > >;

template< bool... Bs >
using bool_or = std::integral_constant< bool, !bool_and< !Bs... >::value >;

它们可以作为更高级和专业特征的构建块派上用场。例如，您可以像这样使用它们：

typename< typename R, bool... Bs > // note: R first, no default :(
using enable_if_any = std::enable_if< bool_or< Bs... >::value, R >;

typename< typename R, bool... Bs > // note: R first, no default :(
using enable_if_all = std::enable_if< bool_and< Bs... >::value, R >;

typename< typename T, typename... Ts >
using are_same = bool_and< std::is_same< T, Ts >::value... >;
于 2014-07-10T22:12:48.720 回答
1

您还可以使用std::conditional以实现enable_if_alland enable_if_any：

#include <type_traits>
#include <iostream>
#include <initializer_list>
#include <string>

namespace detail
{
template <typename... Conds>
struct and_ : std::true_type {};

template <typename... Conds>
struct or_ : std::false_type {};

template <typename Cond, typename... Conds>
struct and_<Cond, Conds...>
    : std::conditional<Cond::value, detail::and_<Conds...>, std::false_type>::type {};

template <typename Cond, typename... Conds>
struct or_<Cond, Conds...>
    : std::conditional<Cond::value, std::true_type, detail::and_<Conds...>>::type {};
}

template <typename... T>
using are_all_pod = detail::and_<std::is_pod<T>...>;

template <typename... T>
using any_is_pod = detail::or_<std::is_pod<T>...>;

template <typename... Args, typename = typename std::enable_if<are_all_pod<Args...>::value>::type>
void f(Args... args)
{
  (void)std::initializer_list<int>{(std::cout << args << '\n' , 0)...};
}

template <typename... Args, typename = typename std::enable_if<any_is_pod<Args...>::value>::type>
void g(Args... args)
{
  (void)std::initializer_list<int>{(std::cout << args << '\n' , 0)...};
}

int main()
{
  std::string s = "hello";  // non pod
  //f(1, 1.2, s); // this will fail because not all types are pod
  g(1, 1.2, s);   // this compiles because there is at least one pod in argument pack 
}
于 2016-07-08T15:47:46.880 回答
1

受 Daniel Fray 回答中的绝妙想法的启发，我们甚至可以扩展这些可变参数特征的范围。使用元组，我们可以将特征应用于可变参数类型包的集合，而不是“仅”将可变参数类型包与引用类型进行比较。

例如，我们将能够查看类型是否与（确实是！）int, int, int, float类型相同。int, int, int, float

为此，我们需要以下构造：

  • 元组和产生元组尾部的方法
  • 一种通过向布尔值附加（或预先附加）布尔值来扩展布尔序列的方法

TL;博士

我在此编译了一些示例live demo。

定义可变特征设施

首先，我们提供了一个帮助器来一次扩展一个布尔序列一个值：

template <bool ... Bs>
struct bool_sequence {};

template <bool b, typename T>
struct prepend_bool_seq;

template <bool b, bool ... bs>
struct prepend_bool_seq<b, bool_sequence<bs...>> {
    typedef bool_sequence<b, bs...> type;
};

现在关于布尔序列的一些逻辑（取自其他答案）

template <typename T>
struct all_of;

template <bool ... Bs>
struct all_of<bool_sequence<Bs...>> :
    public std::is_same<bool_sequence<true, Bs...>, bool_sequence<Bs..., true>> {};

template <typename T>
struct any_of;

template <bool ... Bs>
struct any_of<bool_sequence<Bs...>> :
    public std::integral_constant<bool, !all_of<bool_sequence<!Bs...>>::value> {};

然后，我们定义一个辅助模板来访问元组的尾部：

namespace details {

// Sentinel type to detect empty tuple tails
struct null_type {};

template <typename T>
struct tuple_tail;

template <typename T>
struct tuple_tail<std::tuple<T>> {
    typedef null_type type;
};

template <typename T, typename ... Ts>
struct tuple_tail<std::tuple<T, Ts...>> {
    typedef std::tuple<Ts...> type;
};

}

组合结构

有了这些积木，我们现在可以定义一个apply_trait模板来在几个类型列表上应用给定的类型特征：

namespace details {

template <template <typename...> class Trait, typename ... Tuples>
struct apply_trait {
    static constexpr bool atomic_value =
                     Trait<typename std::tuple_element<0u, Tuples>::type...>::value;
    typedef typename prepend_bool_seq<atomic_value,
                     typename apply_trait<Trait,
                     typename tuple_tail<Tuples>::type...>::type>::type type;
};

template <template <typename...> class Trait, typename ... Tuples>
struct apply_trait<Trait, null_type, Tuples...> {
    typedef bool_sequence<> type;
};

}

该模板以自下而上的方式递归地计算特征应用程序给出的布尔序列。现在，提供了结果 bool 序列，我们可以使用上面定义的助手对结果执行逻辑运算。

are_same接下来，一些助手可以为任何二元（或一元）类型特征重现您的示例逻辑：

// Helper templates for common type traits (unary and binary)
template <template <typename> class UnaryTrait, typename ... Ts>
using apply_unary_trait = details::apply_trait<UnaryTrait, std::tuple<Ts...>>;

template <template <typename, typename> class BinaryTrait, typename Ref, typename ... Ts>
using apply_binary_trait = details::apply_trait<BinaryTrait,
                                                std::tuple<decltype(std::declval<Ts>(), std::declval<Ref>())...>,
                                                std::tuple<Ts...>>;

template <template <typename, typename> class BinaryTrait, typename Ref, typename ... Ts>
using apply_binary_trait_ref_last = details::apply_trait<BinaryTrait,
                                             std::tuple<Ts...>,
                                             std::tuple<decltype(std::declval<Ts>(), std::declval<Ref>())...>>;

例如，我们可以重现are_same您为每个二元特征提出的设计：

template <typename Ref, typename ... Ts>
using are_same = all_of<typename apply_binary_trait<std::is_same, Ref, Ts...>::type>;

我们还可以将特征逻辑应用于列表。例如，给定两个类型列表，我们可能想要检查第一个列表中的类型是否可以转换为第二个列表中的匹配类型：

// int is convertible to long and char const* is convertible to std::string
std::cout << all_of<details::apply_trait<std::is_convertible,
                                         std::tuple<int, char const*>,
                                         std::tuple<long, std::string>::type>::value;
于 2016-07-27T14:57:07.133 回答