C++ 从模板参数创建元组向量

C++ Creating vector of tuples from template arguments

本文关键字：创建元组向量参数 C++ 更新时间：2023-10-16

我有以下代码：

template <typename Type, typename Handler>
struct InternalColumn
{
column(Type* data, Handler h): data_(data), h_(h) {}
// overloaded functions for data binding ( int, char, long..)
template<typename SourceData>
void bindData(SourceData src){...}
...
Type* data_; // pointer to external data
Handler h_; // for some reasons
};
template <typename Columns, typename Handler>
writeDataFunc(Columns&& cols, Handler h)
{
// here i need to create here some tuples InternalColumn<T,H> vector
// vector<InternalColumn<T,H>> vt;   how can I create it from incoming vector?
// then in loop - internCol.bind(col);
// 
// write data 
//
// call handler h(cols); 
}
// i also have stuff like this:
template<typename T, typename H>
auto makeColumn(T* data, H h) 
{
return column<T, H>(data, h);
}
main()
{
int i= 0;
char c[32] = {0};
long l = 0;
writeDataFunc(boost::fusion::vector_tie(i,c,l), [&](auto& col)
{
// working with i, c, l variables
});
}

所以我的问题出在writeDataFunc.我无法创建内部列外部并将它们传递给vector_tie。它应该是 POD 类型。

我的问题是：是否可以在writeDataFunc中创建一个内部列向量(boost，元组向量(？

请有任何想法，或者如果我不清楚。

除非它们具有相同的类型 T，否则您无法创建 InternalColumn 的 std：：vector，所以我猜您想创建融合向量。我改用了一个std：：tuple，这非常相似。只要 InternalColumn 类型不同，下面的解决方案就可以工作(因为我使用该类型作为 std：：get 的键(。为了概括它，可以创建一个 std：：index_sequence 并通过索引访问元组

#include <tuple>                                                                                                                                                                                                                                                                          
template <typename Type, typename Handler>                                                                                                                                                                                                                                                
struct InternalColumn                                                                                                                                                                                                                                                                     
{                                                                                                                                                                                                                                                                                         
InternalColumn(Type& data, Handler h): data_(data), h_(h) {}                                                                                                                                                                                                                           
// overloaded functions for data binding ( int, char, long..)                                                                                                                                                                                                                          
template<typename SourceData>                                                                                                                                                                                                                                                          
void bindData(SourceData src){}                                                                                                                                                                                                                                                        

Type& data_; // pointer to external data                                                                                                                                                                                                                                                  
Handler h_; // for some reasons                                                                                                                                                                                                                                                           
};                                                                                                                                                                                                                                                                                        
template<typename Lambda, typename Tuple, int ID=0>                                                                                                                                                                                                                                       
void for_each_tuple(Lambda&& l, Tuple& t){                                                                                                                                                                                                                                                
l(std::get<ID>(t));                                                                                                                                                                                                                                                                   
if constexpr(ID < std::tuple_size<Tuple>::value-1)                                                                                                                                                                                                                                    
for_each_tuple<Lambda, Tuple, ID+1>(l, t);                                                                                                                                                                                                                            
}                                                                                                                                                                                                                                                                                         
template <template <typename ...> class Tuple, typename Handler, typename ... Types>                                                                                                                                                                                                      
int writeDataFunc(Tuple<Types ...>&& cols, Handler h)                                                                                                                                                                                                                                     
{                                                                                                                                                                                                                                                                                         
Tuple<InternalColumn<Types, Handler> ...> vt{InternalColumn{std::get<Types>(cols), h} ...};                                                                                                                                                                                           
for_each_tuple(h, vt);                                                                                                                                                                                                                                                                
}                                                                                                                                                                                                                                                                                         
// i also have stuff like this:                                                                                                                                                                                                                                                           
template<typename T, typename H>                                                                                                                                                                                                                                                          
auto makeColumn(T* data, H h)                                                                                                                                                                                                                                                             
{                                                                                                                                                                                                                                                                                         
return InternalColumn<T, H>(data, h);                                                                                                                                                                                                                                                  
}                                                                                                                                                                                                                                                                                         
main()                                                                                                                                                                                                                                                                                    
{                                                                                                                                                                                                                                                                                         
int i= 0;                                                                                                                                                                                                                                                                              
char c[32] = {0};                                                                                                                                                                                                                                                                      
long l = 0;                                                                                                                                                                                                                                                                            
writeDataFunc(std::make_tuple(i,c,l), [&](auto& col)                                                                                                                                                                                                                                   
{                                                                                                                                                                                                                                                                                      
// working with i, c, l variables                                                                                                                                                                                                                                                    
});                                                                                                                                                                                                                                                                                    
}