C++: converte il vettore in tupla

Question

Come posso convertire std :: vector in std :: tuple? Ho

class T { }; 
int cnt = 3; 
vector<T*> tv; 
for (int i = 0; i < cnt; ++i) { 
    tv.push_back(new T()); 
} 

voglio ottenere

auto tp = std::tie(*tv[0], *tv[1], *tv[2]); 

Come posso ottenere questo tp? Se cnt è abbastanza grande, non posso scrivere questo tp manualmente.

std::vector< 
    ConvConnection< 
    decltype(inputLayer), 
    decltype(*C1[0]), 
    decltype(*Conn1Opt[0]), 
    RandomInitialization<arma::mat>, 
    arma::mat 
    >* > Conn1(6); 

    for (size_t i = 0; i < 6; ++i) { 
    Conn1.push_back(new ConvConnection< 
        decltype(inputLayer), 
        decltype(*C1[0]), 
        decltype(*Conn1Opt[0]), 
        RandomInitialization<arma::mat>, 
        arma::mat 
        >(inputLayer, *C1[i], *Conn1Opt[i], 5, 5)); 
    } 

Questo è il codice. Ecco solo 6, ma ho anche bisogno di un vettore con una dimensione superiore a 100. Ho bisogno di convertire questo vettore in una tupla.

Answer 1

Non puoi proprio. Poiché la dimensione del vettore è nota al runtime, ma il tipo tuple (che include le sue dimensioni) deve essere noto al momento della compilazione.

Answer 2

Generalmente, non è possibile convertire un vector in un tuple. Tuttavia, se tutti si sta cercando di fare è rendere la tupla <f(0), f(1), ..., f(N-1)> per qualche N che è una costante espressione, allora questo è fattibile con il trucco sequenza di indice:

template <typename F, size_t... Is> 
auto gen_tuple_impl(F func, std::index_sequence<Is...>) { 
    return std::make_tuple(func(Is)...); 
} 

template <size_t N, typename F> 
auto gen_tuple(F func) { 
    return gen_tuple_impl(func, std::make_index_sequence<N>{}); 
} 

che possiamo usare come:

// make a tuple of the first 10 squares: 0, 1, 4, ..., 81 
auto squares = gen_tuple<10>([](size_t i){ return i*i;}); 

Per il vostro specifico caso d'uso, che sarebbe:

auto connections = gen_tuple<6>([&](size_t i) { 
    return new ConvConnection< 
       decltype(inputLayer), 
       decltype(*C1[0]), 
       decltype(*Conn1Opt[0]), 
       RandomInitialization<arma::mat>, 
       arma::mat 
       >(inputLayer, *C1[i], *Conn1Opt[i], 5, 5); 
}); 

Answer 3

Se si dispone di C++ 14, si può fare in questo modo:

template <typename T, std::size_t... Indices> 
auto vectorToTupleHelper(const std::vector<T>& v, std::index_sequence<Indices...>) { 
    return std::make_tuple(v[Indices]...); 
} 

template <std::size_t N, typename T> 
auto vectorToTuple(const std::vector<T>& v) { 
    assert(v.size() >= N); 
    return vectorToTupleHelper(v, std::make_index_sequence<N>()); 
} 

Grazie alla deduzione automatica, questo è ok. In C++ 11, senza deduzione automatica, è necessario scrivere i tipi restituiti con il trailing decltype. Devi anche implementare il tuo index_sequence.