拆分参数包
Split paramter pack
我想拆分一个模板参数包。像这样的东西。 我该怎么做呢?
template< typename... Pack >
struct TypeB : public TypeA< get<0, sizeof...(Pack)/2>(Pack...) >
, public TypeA< get<sizeof...(Pack)/2, sizeof...(Pack)>(Pack...) >
{
};
以下是我对为什么这个问题不是重复的看法: 我正在寻找一种通用的方法来实现这一点,该方法在将拆分包传递给其他模板类时有效 - 如上所示。以及将其传递给函数。
我想有很多方法可以做到这一点。
如果你能至少使用C++14,我建议使用decltype()
的力量,std::tuple_cat()
如下:
(1) 声明(没有定义的理由,因为通过decltype()
几个重载(和 SFINAE 启用/禁用)使用,如下所示
template <std::size_t Imin, std::size_t Imax, std::size_t I, typename T>
std::enable_if_t<(Imin <= I) && (I < Imax), std::tuple<T>> getTpl ();
template <std::size_t Imin, std::size_t Imax, std::size_t I, typename>
std::enable_if_t<(I < Imin) || (Imax <= I), std::tuple<>> getTpl ();
这个想法是在索引处于正确范围内时返回std::tuple<T>
,否则std::tuple<>
。
(2) 定义一个帮助类,将std::tuple<Ts...>
转换为TypeA<Ts...>
template <typename>
struct pta_helper2;
template <typename ... Ts>
struct pta_helper2<std::tuple<Ts...>>
{ using type = TypeA<Ts...>; };
(3) 定义一个帮助程序类,该类仅在元组中连接正确范围内的类型
template <std::size_t, std::size_t, typename ... Ts>
struct pta_helper1;
template <std::size_t I0, std::size_t I1, std::size_t ... Is, typename ... Ts>
struct pta_helper1<I0, I1, std::index_sequence<Is...>, Ts...>
: public pta_helper2<decltype(std::tuple_cat(getTpl<I0, I1, Is, Ts>()...))>
{ };
这个想法是连接一个std::tuple<>
和std::tuple<T>
序列,其中T
类型是请求范围内的类型;生成的类型(pta_helper2
的模板参数)是一个std::tuple<Us...>
,其中Us...
正是请求范围内的类型。
(4) 定义一个using
类型,以更简单的方式使用前面的帮助程序类
template <std::size_t I0, std::size_t I1, typename ... Ts>
using proTypeA = typename pta_helper1<
I0, I1, std::make_index_sequence<sizeof...(Ts)>, Ts...>::type;
(5)现在你的TypeB
变成了
template <typename ... Ts>
struct TypeB : public proTypeA<0u, sizeof...(Ts)/2u, Ts...>,
public proTypeA<sizeof...(Ts)/2u, sizeof...(Ts), Ts...>
{ };
以下是完整的编译C++14示例示例
#include <tuple>
#include <type_traits>
template <typename ...>
struct TypeA
{ };
template <std::size_t Imin, std::size_t Imax, std::size_t I, typename T>
std::enable_if_t<(Imin <= I) && (I < Imax), std::tuple<T>> getTpl ();
template <std::size_t Imin, std::size_t Imax, std::size_t I, typename>
std::enable_if_t<(I < Imin) || (Imax <= I), std::tuple<>> getTpl ();
template <typename>
struct pta_helper2;
template <typename ... Ts>
struct pta_helper2<std::tuple<Ts...>>
{ using type = TypeA<Ts...>; };
template <std::size_t, std::size_t, typename ... Ts>
struct pta_helper1;
template <std::size_t I0, std::size_t I1, std::size_t ... Is, typename ... Ts>
struct pta_helper1<I0, I1, std::index_sequence<Is...>, Ts...>
: public pta_helper2<decltype(std::tuple_cat(getTpl<I0, I1, Is, Ts>()...))>
{ };
template <std::size_t I0, std::size_t I1, typename ... Ts>
using proTypeA = typename pta_helper1<
I0, I1, std::make_index_sequence<sizeof...(Ts)>, Ts...>::type;
template <typename ... Ts>
struct TypeB : public proTypeA<0u, sizeof...(Ts)/2u, Ts...>,
public proTypeA<sizeof...(Ts)/2u, sizeof...(Ts), Ts...>
{ };
int main()
{
using tb = TypeB<char, short, int, long, long long>;
using ta1 = TypeA<char, short>;
using ta2 = TypeA<int, long, long long>;
static_assert(std::is_base_of<ta1, tb>::value, "!");
static_assert(std::is_base_of<ta2, tb>::value, "!");
}
通过std::tuple
(C++11)和std::index_sequence
(C++14,但有向后移植),标准库包含所有内容,可以有效地和有点方便地拆分包。
template <class, class, class>
struct TypeBImpl;
template <std::size_t... N, std::size_t... M, class T>
struct TypeBImpl<std::index_sequence<N...>, std::index_sequence<M...>, T>
: TypeA<typename std::tuple_element_t<T, N>::type...>
, TypeA<typename std::tuple_element_t<T, M + sizeof...(N)>::type...>
{};
template <class... Ts>
struct TypeB
: TypeBImpl<
std::make_index_sequence<sizeof...(Ts) / 2>,
std::make_index_sequence<(sizeof...(Ts) + 1) / 2>,
std::tuple<std::enable_if<1, Ts>...>
>
{};
为了方便起见,我使用了一个中间基础,这具有保留帮助程序类型以便在成员中重复使用的额外优势。
如果您不需要它,或者它在 RTTI 中的存在不方便,还有其他解决方案:
template <class T, std::size_t N, std::size_t... M>
auto TypeA_part_impl(std::index_sequence<M...>)
-> TypeA<typename std::tuple_element_t<T, N + M>::type...>;
template <bool tail, class... Ts>
using TypeA_part = decltype(TypeA_part_impl<
std::tuple<std::enable_if<1, Ts>...>,
tail * sizeof...(Ts) / 2>(
std::make_index_sequence<(sizeof...(Ts) + tail) / 2>()));
template <class... Ts>
struct TypeB : TypeA_part<0, Ts...>, TypeA_part<1, Ts...>
{
};
我使用std::enable_if<1, T>
作为传输任意类型信息的便捷工具,即使类型如此不规则,无法存储在std::tuple
中,或者不完整。无需定义我自己的。
- 如何反转整数参数包
- 使用C++库在Android项目中修改gradle中的cmake参数,用于插入指令的测试
- 如何使用默认参数等选择模板专业化
- 模板参数替换失败,并且未完成隐式转换
- 具有默认模板参数的多态类的模板推导失败
- lambda参数转换为constexpr技巧,然后获取带链接的数组
- 将数组作为参数传递给函数安全吗?作为第三方职能部门,可以探索他们想要的之外的其他元素
- 函数调用中参数的顺序重要吗
- 使用 C++ 将命令行参数拆分为参数/向量
- 在带括号的字符串中拆分参数
- Doxygen,当参数类型定义使签名相同时,如何拆分函数文档?
- 拆分参数包
- 根据函数指针参数拆分多个可变参数模板包
- 如何使用 c++ 逐行处理文本文件并将其参数拆分为变量?
- 在预处理器中拆分参数C++
- 如何在各个参数中拆分#__VA_ARGS__
- 按给定类型拆分参数包
- 拆分64位值以适应双精度参数类型
- 在c++ /Qt中拆分Lua函数调用的混合字符串/数字参数列表
- 取消对拆分函数调用参数的信任