我正在尝试C++类型列表。下面是一个类型列表过滤器函数的琐碎实现。除了gcc和clang中的编译时间超出了18个元素的范围之外，它似乎还能工作。我想知道我能做些什么改进来实现这一点。
#include <type_traits>
// a type list
template <class... T> struct tl ;
// helper filter for type list
template <class IN_TL, class OUT_TL, template <typename> class P>
struct filter_tl_impl;
// Base case
template <class... Ts, template <typename> class P>
// If the input list is empty we are done
struct filter_tl_impl<tl<>, tl<Ts...>, P> {
using type = tl<Ts...>;
};
// Normal case
template <class Head, class... Tail, class... Ts2, template <typename> class P>
struct filter_tl_impl<tl<Head, Tail...>, tl<Ts2...>, P> {
using type = typename std::conditional<
// Does the predicate hold on the head of the input list?
P<Head>::value,
// The head of the input list matches our predictate, copy it
typename filter_tl_impl<tl<Tail...>, tl<Ts2..., Head>, P>::type,
// The head of the input list does not match our predicate, skip
// it
typename filter_tl_impl<tl<Tail...>, tl<Ts2...>, P>::type>::type;
};
template <class TL, template <typename> class P> struct filter_tl {
using type = typename filter_tl_impl<TL, tl<>, P>::type;
};
// Test code
using MyTypes = tl<
char*, bool, char, int, long, void,
char*, bool, char, int, long, void,
char*, bool, char, int, long, void
>;
using MyNumericTypes = filter_tl<MyTypes, std::is_arithmetic>::type;
static_assert(std::is_same < MyNumericTypes,
tl<
bool,char,int,long,
bool,char,int,long,
bool,char,int,long
>> :: value);
int main(int, char **) {}
using type = typename std::conditional<
// Does the predicate hold on the head of the input list?
P<Head>::value,
// The head of the input list matches our predictate, copy it
typename filter_tl_impl<tl<Tail...>, tl<Ts2..., Head>, P>::type,
// The head of the input list does not match our predicate, skip
// it
typename filter_tl_impl<tl<Tail...>, tl<Ts2...>, P>::type>::type;
由于CCD_ 1而实例化双方。
您可能会在std::conditional:之后延迟中间实例化
using type = typename std::conditional<
// Does the predicate hold on the head of the input list?
P<Head>::value,
// The head of the input list matches our predicate, copy it
filter_tl_impl<tl<Tail...>, tl<Ts2..., Head>, P>,
// The head of the input list does not match our predicate, skip
// it
filter_tl_impl<tl<Tail...>, tl<Ts2...>, P>>::type::type;
这导致实例化的数量是线性的，而不是指数的。
如果想要列表，首先要做的就是定义cons函数。其余部分变得自然而直接。
// first, define `cons`
template <class Head, class T> struct cons_impl;
template <class Head, class ... Tail>
struct cons_impl <Head, tl<Tail...>> {
using type = tl<Head, Tail...>;
};
template <class Head, class T>
using cons = typename cons_impl<Head, T>::type;
// next, define `filter`
template <template <typename> class P, class T>
struct filter_tl_impl;
template <template <typename> class P, class T>
using filter_tl = typename filter_tl_impl<P, T>::type;
// empty list case
template <template <typename> class P>
struct filter_tl_impl<P, tl<>> {
using type = tl<>;
};
// non-empty lust case
template <template <typename> class P, class Head, class ... Tail>
struct filter_tl_impl<P, tl<Head, Tail...>> {
using tailRes = filter_tl<P, tl<Tail...>>;
using type = std::conditional_t<P<Head>::value,
cons<Head, tailRes>,
tailRes>;
};
注意tailRes的定义只是为了可读性，你可以直接写
using type = std::conditional_t<P<Head>::value,
cons<Head, filter_tl<P, tl<Tail...>>>,
filter_tl<P, tl<Tail...>>>;
并且编译时间仍然可以忽略不计。
一个可能的替代方案可以是在filter_tl_impl中插入std::conditional。
我是说
// Normal case
template <typename Head, typename... Tail, typename... Ts2,
template <typename> class P>
struct filter_tl_impl<tl<Head, Tail...>, tl<Ts2...>, P>
{
using type = typename filter_tl_impl<tl<Tail...>,
std::conditional_t<
P<Head>::value,
tl<Ts2..., Head>,
tl<Ts2...>>,
P>::type;
};
现在，对于完全不同的东西。。。
我提议把你的"；正常情况"；(递归情况(在两种不同的情况下：；真"；而情况"；false"；。
不幸的是，这需要额外的自定义类型特征check_first
template <typename, template <typename> class>
struct check_first : public std::false_type
{ };
template <typename H, typename ... T, template <typename> class P>
struct check_first<tl<H, T...>, P>
: public std::integral_constant<bool, P<H>::value>
{ };
现在，您可以按照以下编写filter_tl_impl
// declaration and ground case
template <typename I, typename O, template <typename> class P,
bool = check_first<I, P>::value>
struct filter_tl_impl
{ using type = O; };
// recursive-positive case
template <typename H, typename... T, typename... Ts,
template <typename> class P>
struct filter_tl_impl<tl<H, T...>, tl<Ts...>, P, true>
: public filter_tl_impl<tl<T...>, tl<Ts..., H>, P>
{ };
// recursive-negative case
template <typename H, typename... T, typename... Ts,
template <typename> class P>
struct filter_tl_impl<tl<H, T...>, tl<Ts...>, P, false>
: public filter_tl_impl<tl<T...>, tl<Ts...>, P>
{ };
我还将filter_tl重写为更简单的using
template <typename TL, template <typename> class P>
using filter_tl = typename filter_tl_impl<TL, tl<>, P>::type;
所以你的原始代码变成
#include <type_traits>
// a type list
template <typename...>
struct tl;
template <typename, template <typename> class>
struct check_first : public std::false_type
{ };
template <typename H, typename ... T, template <typename> class P>
struct check_first<tl<H, T...>, P>
: public std::integral_constant<bool, P<H>::value>
{ };
// declaration and ground case
template <typename I, typename O, template <typename> class P,
bool = check_first<I, P>::value>
struct filter_tl_impl
{ using type = O; };
// recursive-positive case
template <typename H, typename... T, typename... Ts,
template <typename> class P>
struct filter_tl_impl<tl<H, T...>, tl<Ts...>, P, true>
: public filter_tl_impl<tl<T...>, tl<Ts..., H>, P>
{ };
// recursive-negative case
template <typename H, typename... T, typename... Ts,
template <typename> class P>
struct filter_tl_impl<tl<H, T...>, tl<Ts...>, P, false>
: public filter_tl_impl<tl<T...>, tl<Ts...>, P>
{ };
template <typename TL, template <typename> class P>
using filter_tl = typename filter_tl_impl<TL, tl<>, P>::type;
// Test code
using MyTypes = tl<char*, bool, char, int, long, void,
char*, bool, char, int, long, void,
char*, bool, char, int, long, void>;
using MyNumericTypes = filter_tl<MyTypes, std::is_arithmetic>;
static_assert(std::is_same_v<MyNumericTypes,
tl<bool, char, int, long,
bool, char, int, long,
bool, char, int, long>>);
int main ()
{ }