Discussion :

[DakM]

Bonjour !

Fiou, quel intitulé

Alors, prenez un tuple simple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::tuple<A,B,C,E,D,...> mon_tuple;

Maintenant, prenez une classe et son constructeur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

class X { X(A,B,C,E,D,...); };

Puis un vecteur de cette classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::vector<X*>

J'aimerais pouvoir faire un emplace_back sur le vecteur, en utilisant mes tuples.

Evidemment, la question du std::tie ne se pose meme pas, trop lourd à la lecture et aussi si je dois changer des choses dans la classe.

Avec une simple rechercher, je tombe sur...
http://stackoverflow.com/questions/6...ions-arguments

Le truc, c'est comment attraper la signature de emplace back d'un vecteur v ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
            collection_t r; // mon vecteur de pointeur
            for(...)
            {
                auto un_tuple = ...
                auto fn = std::mem_fn(&collection_t::emplace_back);
                apply(fn(r), un_tuple);

J'obtiens des erreurs du type:

error: no matching function for call to ‘mem_fn(<unresolved overloaded function type>)’|

Au final, ce que je fais c'est au lieu de faire
tuple -> variables -> emplace_back
j'aimerais sauter l'etapes des variables, et qu'un template depaquetes mon tuple sur une fonction variadic, ici, emplace_back!

Merci, nico

[Arzar]

Bonjour,

emplace_back pour un vector<T> prends des arguments A, B,C ... et construit sur place un objet T en appelant le constructeur T(A, B, C)

Sauf qu'ici tu as un vector<X*> or un X* n'a pas de constructeur (c'est un simple pointeur !) donc ce que tu veux faire n'est pas possible.

Edit : Par contre tu peux faire v.push_back(new X(A, B, C...)).
Pour passer d'un tuple à une liste d'arguments, le moyen le plus simple à mon avis est d'utiliser une liste d'indices template {0, 1, 2, ...}, égal au nombre d'arguments A, B, C..., dans un pack et de l'étaler via std::get<I>(tuple).... comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
template <typename X, typename... Args, size_t... Idx
void push_back_tuple_details(std::vector<X*>& v, 
                             const std::tuple<Args...>& t, 
                             std::index_sequence<Idx...>)
{
    v.push_back(new X(std::get<Idx>(t)...);
}
 
template <typename X, typename... Args>
void push_back_tuple(std::vector<X*>& v, const std::tuple<Args...>& t)
{
   push_back_tuple_details(v, t, std::make_index_sequence<sizeof...(Args)>());
}
 
for(...)
{
   auto un_tuple = ...
   push_back_tuple(v, un_tuple);
}

std::index_sequence et std::make_index_sequence font parti du standard C++14, donc hyper récent et probablement pas dispo sur ton compilateur mais tu peux trouver une implémentation ici :
http://llvm.org/svn/llvm-project/lib...nclude/utility
ou ici :
http://gcc.gnu.org/viewcvs/gcc/trunk...ty?view=markup

Après c'est vrai que ça reste quand même bien compliqué pour ce que ça fait. Dès fois je me prends à rêver d'un mécanisme du langage pour étaler automatiquement les tuple sans avoir à faire tout ce bricolage (un opérateur... peut être ? à voir en C++17...). Du coup en attendant j'essaye d'éviter les tuple au maximum car ils engendrent toujours des complications à n'en plus finir.