C ++ Создание вектора кортежей из аргументов шаблона

Question

У меня есть следующий код:

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. Я не могу создать InternalColumns снаружи и передать их vector_tie.Это должны быть типы POD.

Мой вопрос: Можно ли создать вектор InternalColumn (boost, вектор кортежей) в writeDataFunc?

Пожалуйста, какие-либо мысли илиесли бы я был неясен.

Answer 1

Вы не можете создать std :: vector для InternalColumn, если они не имеют одинаковый тип T, поэтому, я думаю, вы хотели создать векторы слияния.Вместо этого я использовал 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                                                                                                                                                                                                                                                    
   });                                                                                                                                                                                                                                                                                    
}