C ++ 11 emplace_back sur le vecteur <struct>?

Considérez le programme suivant:

#include <string>
#include <vector>

using namespace std;

struct T
{
    int a;
    double b;
    string c;
};

vector<T> V;

int main()
{
    V.emplace_back(42, 3.14, "foo");
}

Ça ne marche pas:

$ g++ -std=gnu++11 ./test.cpp
In file included from /usr/include/c++/4.7/x86_64-linux-gnu/bits/c++allocator.h:34:0,
                 from /usr/include/c++/4.7/bits/allocator.h:48,
                 from /usr/include/c++/4.7/string:43,
                 from ./test.cpp:1:
/usr/include/c++/4.7/ext/new_allocator.h: In instantiation of ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = T; _Args = {int, double, const char (&)[4]}; _Tp = T]’:
/usr/include/c++/4.7/bits/alloc_traits.h:253:4:   required from ‘static typename std::enable_if<std::allocator_traits<_Alloc>::__construct_helper<_Tp, _Args>::value, void>::type std::allocator_traits<_Alloc>::_S_construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = T; _Args = {int, double, const char (&)[4]}; _Alloc = std::allocator<T>; typename std::enable_if<std::allocator_traits<_Alloc>::__construct_helper<_Tp, _Args>::value, void>::type = void]’
/usr/include/c++/4.7/bits/alloc_traits.h:390:4:   required from ‘static void std::allocator_traits<_Alloc>::construct(_Alloc&, _Tp*, _Args&& ...) [with _Tp = T; _Args = {int, double, const char (&)[4]}; _Alloc = std::allocator<T>]’
/usr/include/c++/4.7/bits/vector.tcc:97:6:   required from ‘void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {int, double, const char (&)[4]}; _Tp = T; _Alloc = std::allocator<T>]’
./test.cpp:17:32:   required from here
/usr/include/c++/4.7/ext/new_allocator.h:110:4: error: no matching function for call to ‘T::T(int, double, const char [4])’
/usr/include/c++/4.7/ext/new_allocator.h:110:4: note: candidates are:
./test.cpp:6:8: note: T::T()
./test.cpp:6:8: note:   candidate expects 0 arguments, 3 provided
./test.cpp:6:8: note: T::T(const T&)
./test.cpp:6:8: note:   candidate expects 1 argument, 3 provided
./test.cpp:6:8: note: T::T(T&&)
./test.cpp:6:8: note:   candidate expects 1 argument, 3 provided

Quelle est la bonne façon de procéder et pourquoi?

(Également essayé des accolades simples et doubles)

Pour toute personne du futur, ce comportement sera modifié dans C ++ 20 .

En d'autres termes, même si l'implémentation en interne s'appellera toujours, T(arg0, arg1, ...)elle sera considérée comme régulière T{arg0, arg1, ...}que vous attendez.

Vous devez définir explicitement un cteur pour la classe:

#include <string>
#include <vector>

using namespace std;

struct T
{
    int a;
    double b;
    string c;

    T(int a, double b, string &&c) 
        : a(a)
        , b(b)
        , c(std::move(c)) 
    {}
};

vector<T> V;

int main()
{
    V.emplace_back(42, 3.14, "foo");
}

Le but de l'utilisation emplace_backest d'éviter de créer un objet temporaire, qui est ensuite copié (ou déplacé) vers la destination. Bien qu'il soit également possible de créer un objet temporaire, puis de le transmettre emplace_back, cela va à l'encontre (au moins la plupart) de l'objectif. Ce que vous voulez faire est de passer des arguments individuels, puis laissez emplace_backinvoquer le ctor avec ces arguments pour créer l'objet sur place.

Bien sûr, ce n'est pas une réponse, mais cela montre une fonctionnalité intéressante des tuples:

#include <string>
#include <tuple>
#include <vector>

using namespace std;

using T = tuple <
    int,
    double,
    string
>;

vector<T> V;

int main()
{
    V.emplace_back(42, 3.14, "foo");
}

Si vous ne voulez pas (ou ne pouvez pas) ajouter de constructeur, spécialisez l'allocateur pour T (ou créez votre propre allocateur).

namespace std {
    template<>
    struct allocator<T> {
        typedef T value_type;
        value_type* allocate(size_t n) { return static_cast<value_type*>(::operator new(sizeof(value_type) * n)); }
        void deallocate(value_type* p, size_t n) { return ::operator delete(static_cast<void*>(p)); }
        template<class U, class... Args>
        void construct(U* p, Args&&... args) { ::new(static_cast<void*>(p)) U{ std::forward<Args>(args)... }; }
    };
}

Remarque: La construction de fonction membre illustrée ci-dessus ne peut pas être compilée avec clang 3.1 (Désolé, je ne sais pas pourquoi) Essayez le suivant si vous utilisez clang 3.1 (ou d'autres raisons).

void construct(T* p, int a, double b, const string& c) { ::new(static_cast<void*>(p)) T{ a, b, c }; }

Cela semble être couvert dans le 23.2.1 / 13.

Premièrement, les définitions:

Etant donné un conteneur de type X ayant un allocator_type identique à A et un value_type identique à T et étant donné une lvalue m de type A, un pointeur p de type T *, une expression v de type T, et une rvalue rv de type T, le les termes suivants sont définis.

Maintenant, qu'est-ce qui le rend constructible en place:

T est EmplaceConstructible en X à partir d'arguments, pour zéro ou plusieurs arguments args, signifie que l'expression suivante est bien formée: allocator_traits :: construct (m, p, args);

Et enfin une note sur l'implémentation par défaut de l'appel de construction:

Remarque: Un conteneur appelle allocator_traits :: construct (m, p, args) pour construire un élément en p en utilisant args. La construction par défaut dans std :: allocator appellera :: new ((void *) p) T (args), mais les allocateurs spécialisés peuvent choisir une définition différente.

Cela nous indique à peu près que pour un schéma d'allocateur par défaut (et potentiellement le seul), vous devez avoir défini un constructeur avec le nombre approprié d'arguments pour l'élément que vous essayez de mettre en place dans un conteneur.

vous devez définir un constructeur pour votre type Tcar il contient un constructeur std::stringqui n'est pas trivial.

de plus, il serait préférable de définir (éventuellement par défaut) move ctor / assign (car vous avez un mobile std::stringcomme membre) - cela aiderait à déplacer votre Tbien plus efficace ...

ou, utilisez simplement T{...}pour appeler surchargé emplace_back()comme recommandé dans la réponse de neighboug ... tout dépend de vos cas d'utilisation typiques ...

Vous pouvez créer l' struct Tinstance, puis la déplacer vers le vecteur:

V.push_back(std::move(T {42, 3.14, "foo"}));

Vous pouvez utiliser la {}syntaxe pour initialiser le nouvel élément:

V.emplace_back(T{42, 3.14, "foo"});

Cela peut être optimisé ou non, mais cela devrait l'être.

Vous devez définir un constructeur pour que cela fonctionne, notez qu'avec votre code, vous ne pouvez même pas faire:

T a(42, 3.14, "foo");

Mais c'est ce dont vous avez besoin pour travailler sur place.

donc juste:

struct T { 
  ...
  T(int a_, double b_, string c_) a(a_), b(b_), c(c_) {}
}

le fera fonctionner de la manière souhaitée.