Expand std:: tuple à utiliser comme initialiseur pour la classe
je veux utiliser tous les éléments d'un std::tuple comme initialisateur pour une classe. Est-il un moyen plus simple que de le faire <!-Pour chaque élément du tuple?
exemple de travail Minimum avec std::get:
#include <string>
#include <tuple>
#include <cassert>
struct A
{
std::string string1;
int intVal;
std::string string2;
};
int main()
{
std::tuple< std::string, int, std::string > myTuple("S1", 42, "S2");
A myA{ std::get<0>(myTuple), std::get<1>(myTuple), std::get<2>(myTuple) };
assert( myA.string1 == "S1" );
assert( myA.intVal == 42 );
assert( myA.string2 == "S2" );
}
http://coliru.stacked-crooked.com/a/4a5d45dbf1461407 pour Vivre exemple
2 réponses
Kerrek SB commenté il y a déjà une proposition pour ce P0209R0. Par conséquent, jusqu'à ce que ce soit dans la norme, vous pouvez faire quelque chose dans ce sens:
template<typename C, typename T, std::size_t... I>
decltype(auto) make_from_tuple_impl(T &&t, std::index_sequence<I...>) {
return C{std::get<I>(std::forward<T>(t))...};
}
template<typename C, typename... Args, typename Indices = std::make_index_sequence<sizeof...(Args)>>
decltype(auto) make_from_tuple(std::tuple<Args...> const &t) {
return make_from_tuple_impl<C>(t, Indices());
}
Et initialiser votre classe:
A myA{make_from_tuple<A>(myTuple)};
Vous pouvez aussi la main-artisanat index_sequence et make_index_sequence pour que cela fonctionne en C++11 proposé par Jarod42ici, et le changement à:
namespace idx {
template <std::size_t...> struct index_sequence {};
template <std::size_t N, std::size_t... Is>
struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};
template <std::size_t... Is>
struct make_index_sequence<0u, Is...> : index_sequence<Is...> { using type = index_sequence<Is...>; };
}
template<typename C, typename T, std::size_t... I>
C make_from_tuple_impl(T &&t, idx::index_sequence<I...>) {
return C{std::get<I>(std::forward<T>(t))...};
}
template<typename C, typename... Args, typename Indices = idx::make_index_sequence<sizeof...(Args)>>
C make_from_tuple(std::tuple<Args...> const &t) {
return make_from_tuple_impl<C>(t, Indices());
}
Je ne pense pas qu'il y ait quelque chose de standard qui pourrait vous aider.
Cependant, vous pouvez le faire de la façon suivante:
c-torA?
struct A
{
std::string string1;
int intVal;
std::string string2;
template<class T>
A(const T &t) :
string1(std::get<0>(t),
intVal(std::get<1>(t)),
string2(std::get<2>(t)){}
};
alternativement vous pouvez faire la fonction d'usine comme:
template<class T>
A createA(const T &t){
return A {
std::get<0>(t),
std::get<1>(t),
std::get<2>(t)
};
}
le Code n'a pas été testé et pourrait avoir des erreurs de syntaxe.