包扩展内的整数增量

Question

我有两个功能row和col 。 row是col的包装，应将返回类型包装到元组中。

像这样

#include <iostream>
#include <tuple>

template<typename T>
T col(size_t i)
{
    return T(i);
}

template<typename ...Ts>
auto row()
{
    size_t i = 0;
    return std::make_tuple(col<Ts>(i++)...); //<-- undefined behaviour
}

int main()
{
    auto m_row = row<int,int,double>(); //should expand to std::make_tuple(col<int>(0),col<int>(1),col<double(2));
    std::cout << "std::get<0>(m_row)-" << std::get<0>(m_row) << std::endl;
    std::cout << "std::get<1>(m_row)-" << std::get<1>(m_row) << std::endl;
    std::cout << "std::get<2>(m_row)-" << std::get<2>(m_row) << std::endl;
    return 0;
}

我的问题是整数i必须在扩展内从0递增到sizeof...(Ts) 。 我已经考虑了当前类型的索引，但是如果类型不是唯一的，那么这将不起作用。 我缺乏其他想法，将不胜感激。

Answer 1

使用std :: index_sequence_for我们可以实现一个中等程度的简单（但不像我希望的那样简单）的解决方案。

正如@NathanOliver所提到的，它需要一定程度的间接访问，因为我们需要将索引序列通知给辅助函数。 现在，顶层函数如下所示：

template <typename... Ts>                                                         
auto row() {                                                                      
    return make_row(std::tuple<Ts...>{},                                          
            std::index_sequence_for<Ts...>{});                                    
}         

因此，辅助函数将采用请求的类型的默认构造tuple以及整数的编译时间序列。

现在助手需要做的就是使用索引序列（0、1，...）构造一个Tuple 。

template <typename Tuple, std::size_t... Is>                                      
auto make_row(Tuple, std::index_sequence<Is...>) {                                
    return Tuple{ Is... };                                                        
}                                                                                 

最后，要验证此功能是否符合我们的要求：

int main()                                                                        
{                                                                                 
    auto r = row<int,int,double>();                                               
    static_assert(std::is_same<decltype(r), std::tuple<int, int, double>>::value);
}