std::tuple 类型到另一个类型

Question

如何迭代元组（使用 C++11）？ 我尝试了以下方法：

for(int i=0; istd::tuple_size<T...::value; ++i) std::get(my_tuple).do_sth(); 但这不起作用：

错误 1：抱歉，未实现：无法将“Listener...”扩展为固定长度的参数列表。 错误 2：i 不能出现在常量表达式中。

那么，我如何正确地迭代元组的元素呢？

Answer 1

使用类似的元 function

template <template <typename> typename Transformer, typename... Ts> 
auto transform_types(std::tuple<Ts...>) -> std::tuple<typename Transformer<Ts>::type...>;

您可以创建一个类型特征，例如

template <template <typename> typename Transformer, typename Tuple>
using transform_types_t = decltype(transform_types<Transformer>(std::declval<Tuple>()));

然后你会像使用它一样

using transformed_tuple = transform_types_t<Transforming, TUPLE>;

现在transformed_tuple是一个std::tuple<int, float, int, short int, float, float> 。 你可以在这个活生生的例子中看到它的工作原理

Answer 2

C++模板有一种参数称为模板模板参数，它是一个模板参数，它本身就是一个模板。 这些类型的参数可用于提供像Transforming<T>这样的模板。

示例：

#include <tuple>

// Original trait
template<typename ...> struct Transforming;
template<typename T> struct Transforming<T> { using type = T; };
template<> struct Transforming<char> { using type = int; };
template<> struct Transforming<long> { using type = int; };
template<> struct Transforming<double> { using type = float; };

// T is a template template parameter
// It is a `class` template which has a single `class` template parameter
// Tuple is the tuple of types to transform
template<template<class> class T, class Tuple>
struct transform_types;

// Specialize for `std::tuple` to extract argument types
template<template<class> class T, class ... A>
struct transform_types<T, std::tuple<A...>>
{
    // Make a new `std::tuple` with the transformed types
    // Expand the parameter pack using the template class `T`
    using type = std::tuple<typename T<A>::type...>;
};

template<template<class> class T, class Tuple>
using transform_types_t = typename transform_types<T, Tuple>::type;

// Demonstration
using input_tuple = std::tuple<int, float, char, short, double, double>;
using transformed = transform_types_t<Transforming, input_tuple>;
using expected = std::tuple<int, float, int, short, float, float>;

#include <type_traits>
static_assert(std::is_same_v<transformed, expected>);

Answer 3

你可以这样做：

#include <iostream>
#include <type_traits>
#include <tuple>

template<typename ...> struct Transforming;
template<typename T> struct Transforming<T> { using type = T; };
template<> struct Transforming<char> { using type = int; };
template<> struct Transforming<long> { using type = int; };
template<> struct Transforming<double> { using type = float; };

template <template<typename...> class Transform,typename T>
struct Transformed;

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


int main() {
    using t = std::tuple<char,long,double>;
    using transformed = Transformed<Transforming,t>::type;
    using expected = std::tuple<int,int,float>;
    std::cout << std::is_same_v< transformed,expected>;
}