[英]How to call a generic function with typename and non-typename template arguments?
[英]How can a recover the non-typename template argument from each type in a variadic pack of template classes?
我试图从各种类的模板类包中恢复非类型名模板参数(每个类都有一个非类型参数),以便可以将它们用作另一种类型的整数序列。
下面的代码显示了我所拥有的。 整数序列/成员序列从元组中抄写。
template<std::size_t... Integers>
struct size_t_sequence {
using type = size_t_sequence<Integers...>;
};
template <std::size_t, typename>
struct push_size_t_sequence;
template <std::size_t I, std::size_t... Integers>
struct push_size_t_sequence<I, size_t_sequence<Integers...>>
: size_t_sequence<I, Integers...> {};
template <std::size_t N, std::size_t Head, std::size_t... Tail>
struct make_size_t_sequence
: push_size_t_sequence<Head, typename make_size_t_sequence<N - 1, Tail...>::type>::type {};
template<std::size_t I, std::size_t... OneLeft>
struct make_size_t_sequence <2, I, OneLeft...> :
push_size_t_sequence<I, size_t_sequence<OneLeft...>>::type {};
template<typename... Members>
struct member_sequence {
using type = member_sequence<Members...>;
};
template <typename, typename>
struct push_member_sequence;
template <typename M, typename... Members>
struct push_member_sequence<M, member_sequence<Members...>>
: member_sequence<M, Members...> {};
template <std::size_t N, typename Head, typename... Tail>
struct make_member_sequence
: push_member_sequence<Head, typename make_member_sequence<N - 1, Tail...>::type>::type {};
template<typename M, typename... OneLeft>
struct make_member_sequence <2, M, OneLeft...> :
push_member_sequence<M, member_sequence<OneLeft...>>::type {};
template<typename>
struct unpack_sequence_impl;
template<template<std::size_t> class... T, std::size_t... DimensionSizes>
struct unpack_sequence_impl<member_sequence<T<DimensionSizes>...>> {
using member_types = member_sequence<T<DimensionSizes>...>;
using size_types = size_t_sequence<DimensionSizes...>;
};
template<typename... Members>
struct unpack_sequence :
unpack_sequence_impl<make_member_sequence<sizeof...(Members), Members...>> {
using base_t = unpack_sequence_impl<make_member_sequence<sizeof...(Members), Members...>>;
using member_types = typename base_t::member_types;
using size_types = typename base_t::size_types;
};
template<std::size_t N>
class example {
int s = N;
};
int main()
{
auto mem_sequence = make_member_sequence<3, example<3>, example<2>, example<1>>::type();
auto integer_sequence = make_size_t_sequence<3, 3,2,1>::type();
auto un_mem_sequence = unpack_sequence<example<3>, example<2>, example<1>>::member_types();
auto un_size_sequence = unpack_sequence<example<3>, example<2>, example<1>>::size_types();
}
mem_sequence
和integer_sequence
的类型为member_sequence<example<3>,example<2>,example<1>>
和size_t_sequence<3,2,1>
。 un_mem_sequence
和un_size_sequence
的类型应该相同。
我该怎么做?
谢谢您的帮助!
蒂姆
编辑:
为了澄清起见,我要完成的工作是从一个模板类中恢复模板参数,以在另一个模板中使用它们。 以下是三个模板类: MyObject
, MyTuple
和MyPack
。 MyTuple
将MyObject
对象作为其模板参数。 我想恢复MyObject
模板参数以用作MyPack
对象的模板参数。
template<int N>
MyObject;
template<int... Ns>
MyPack;
template<typename... MyObjects>
MyTuple {};
int main() {
MyTuple<MyObject<1>,MyObject<2>,MyObject<3>> a;
MyPack<1,2,3> b;
}
所以我想从MyTuple的MyObject的参数中提取参数,以用于创建MyPack。
编辑2:
第二个澄清: MyTuple
不仅接受MyObject
类型,还接受具有一个int模板参数的任何类型。
template<int N>
MyObject;
template<int N>
MyObject2;
template<int... Ns>
MyPack;
template<typename... MyObjects>
MyTuple {};
int main() {
MyTuple<MyObject<1>,MyObject<2>,MyObject2<1>,MyObject2<2>> a;
MyPack<1,2,1,2> b;
}
template <typename>
struct MakeMyPack;
template <int... Ns>
struct MakeMyPack<MyTuple<MyObject<Ns>...>>
{
using type = MyPack<Ns...>;
};
为了澄清起见,我要完成的工作是从一个模板类中恢复模板参数,以在另一个模板中使用它们。 下面是三个模板类:MyObject,MyTuple,MyPack。 MyTuple将MyObject对象作为其模板参数。 我想恢复MyObject模板参数以用作MyPack对象的模板参数。
只是为了好玩,我提出了一个更通用的解决方案,该方案具有双可变参数模板(template-template和value template), MyTuple
于MyTuple
和MyObject
template <typename>
struct getMyPack;
template <template <typename...> class C,
template <int> class ... Cs, int ... Is>
struct getMyPack<C<Cs<Is>...>>
{ using type = MyPack<Is...>; };
以下是完整的编译示例
#include <type_traits>
template <int>
struct MyObject1
{ };
template <int>
struct MyObject2
{ };
template <int...>
struct MyPack
{ };
template <typename...>
struct MyTuple
{ };
template <typename>
struct getMyPack;
template <template <typename...> class C,
template <int> class ... Cs, int ... Is>
struct getMyPack<C<Cs<Is>...>>
{ using type = MyPack<Is...>; };
int main ()
{
using T0 = MyTuple<MyObject1<1>, MyObject2<2>, MyObject1<3>>;
using T1 = MyPack<1, 2, 3>;
using T2 = typename getMyPack<T0>::type;
static_assert( std::is_same<T1, T2>::value, "!" );
}
-编辑-
第二个澄清:MyTuple不仅接受MyObject类型,还接受具有一个int模板参数的任何类型。
正如我所怀疑的那样。
我的解决方案与MyObject
无关,因此应该可以工作。
前面的示例已修改以显示它。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.