Question

有没有办法剥离 std::tuple<T...>才能将其恢复为T...？

示例

假设vct<T...>是预先存在的 可变参数类模板，

using U = std::tuple<int,char,std::string>;
using X = vct<int,char,std::string>;
using Y = vct< strip<U> >;            // should be same as X

备注

我知道std::tuple_element，但我需要所有元素，其形式可用作T...

作为参考，我发现这个question，它是相似的，但我的需求稍微简单一点（所以我希望有一个更简单的解决方案）：我需要的只是{{ {1}} - 我不关心tuple实例的实际值。

Answer 1

template<typename>
struct strip;

template<typename ...T>
struct strip<std::tuple<T...>>
{
   using type = vct<T...>;
};

然后将其用作：

using Y = strip<U>::type;

现在Y与X相同。

Answer 2

不，这是不可能的。参数包是类型推导的结果，不能在其他上下文中生成。

你可以采取类似于你所要求的方式：

template<template<typename...> class T, typename>
struct instantiate_with_arg_pack { };

template<template<typename...> class T, typename... Ts>
struct instantiate_with_arg_pack<T, std::tuple<Ts...>>
{
    using type = T<Ts...>;
};

template<typename... Ts>
struct vct { };

int main()
{
    using U = std::tuple<int,char,std::string>;
    using X = vct<int,char,std::string>;
    using Y = instantiate_with_arg_pack<vct, U>::type;
}

实际上，您不需要在元组中保存参数包：任何可变参数类模板都可以：

template<template<typename...> class T, typename>
struct instantiate_with_arg_pack { };

template<
    template<typename...> class T, 
    template<typename...> class U, // <===
    typename... Ts
    >
struct instantiate_with_arg_pack<T, U<Ts...>>
//                                   ^^^^^^^^
{
    using type = T<Ts...>;
};

template<typename... Ts>
struct vct { };

int main()
{
    using U = std::tuple<int,char,std::string>;
    using X = vct<int,char,std::string>;
    using Y = instantiate_with_arg_pack<vct, X>::type;
    //                                        ^

    // Won't fire
    static_assert(
        std::is_same<Y, vct<int,char,std::string>>::value, 
        "Error!");
}

这是一个live example。

Answer 3

你不能直接“返回”参数包，所以你需要的是这样的：

template< typename... Ts >
struct vct
{ ... };

template< typename T >
struct make_vct;

template< typename... Ts >
struct make_vct< std::tuple< Ts... > >
{
    typedef vct< Ts... > type;
};

并使用

using Y = make_vct< U >::type;

Answer 4

此处的目标是能够将参数包从模板实例复制到另一个模板。我没有将其限制为tuple，因为...为什么要将其限制为tuple？

template<template<typename...>class Target, typename Src>
struct copy_pack_types;

template<template<typename...>class Target, template<typename...>class Src, typename... Ts>
struct copy_pack_types< Target, Src<Ts...> > {
  typedef Target<Ts...> type;
};

template<template<typename... Ts>class Target, typename Src>
using CopyPackTypes = typename copy_pack_types<Target, Src>::type;

#include <string>
#include <tuple>
template<typename... Ts> struct vct;
template<typename... Ts> struct vct2;
using U = std::tuple<int,char,std::string>;
using X = vct<int,char,std::string>;
using Y = CopyPackTypes< vct, U >;            // should be same as X
using Z = CopyPackTypes< vct2, U >;            // should be different from X

#include <iostream>
#include <type_traits>
int main() {
  std::cout << std::is_same< X, Y >::value << "\n";
  std::cout << std::is_same< Z, Y >::value << "\n";
  std::cout << std::is_same< Z, vct2<int,char,std::string> >::value << "\n";
}

按预期输出“1 0 1”。

CopyPackTypes采用目标模板，并将从参数包构造的源类型作为其唯一参数。然后，它将参数包复制到目标模板。

一种标准技术是携带参数包是为了创建一个不使用的类型，如：

template<typename...>
struct types {};

仅作为类型列表的占位符存在。然后，您可以将其中一些传递给另一个模板，并且每个包都不会相互“踩”。当您需要将其应用于目标模板时，可以使用上述“CopyPackTypes”之类的内容来应用它。

类似的技术用于索引包：

template<size_t...>
struct seq {};

否则无用的类型是“黑色板岩”来携带一堆参数。

Answer 5

使用c ++ 17 std::apply。

using U = std::tuple<int, char, std::string>;
using X = vct<int, char, std::string>;
using Y = vct<strip<U>>; // should be same as X

auto my_y = std::apply(
        [](auto... ts) {
            using Y = vct<decltype(ts)...>;
            return Y{};
        },
        U{});

如何剥离元组＆lt;＆gt;回到可变参数模板类型列表？

5 个答案: