C ++ 11 emplace_back на векторі <struct>?

Розглянемо таку програму:

#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");
}

Це не працює:

$ 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

Який правильний спосіб це зробити і чому?

(Також пробували одинарні та подвійні брекети)

Для будь-кого з майбутнього ця поведінка буде змінена в C ++ 20 .

Іншими словами, навіть незважаючи на те, що впровадження всередині буде все одно викликати, T(arg0, arg1, ...)це буде вважатися регулярним, T{arg0, arg1, ...}що ви очікуєте.

Вам потрібно чітко визначити ctor для класу:

#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");
}

Суть використання emplace_backполягає у тому, щоб уникнути створення тимчасового об’єкта, який потім копіюється (або переміщується) до місця призначення. Хоча можна також створити тимчасовий об'єкт, а потім передати його emplace_back, він перемагає (принаймні більшу частину) мети. Що ви хочете зробити, це передати окремі аргументи, а потім дозволити emplace_backвикликати ctor з цими аргументами, щоб створити об’єкт на місці.

Звичайно, це не відповідь, але це показує цікаву особливість кортежів:

#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");
}

Якщо ви не хочете (або не можете) додати конструктор, спеціалізуйтесь на розподільнику для T (або створіть власний розподільник).

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)... }; }
    };
}

Примітка: Наведена вище конструкція функції-члена не може компілюватись із clang 3.1 (Вибачте, я не знаю чому). Спробуйте наступний, якщо ви будете використовувати кланг 3.1 (або з інших причин).

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

Здається, це висвітлено у 23.2.1 / 13.

По-перше, визначення:

Дано контейнер типу X, який має тип_розподілювача, ідентичний A, і тип_значення, ідентичний T, і дане значення l типу A, вказівник p типу T *, вираз v типу T та значення rv rv типу T, визначені наступні терміни.

Тепер, що робить його зручним для побудови:

T є EmplaceConstructible в X з args, для нуля або більше аргументів args, означає, що наступний вираз добре сформований: allocator_traits :: construct (m, p, args);

І, нарешті, примітка про реалізацію виклику конструкції за замовчуванням:

Примітка: Контейнер викликає allocator_traits :: construct (m, p, args) для побудови елемента з p за допомогою args. Конструкція за замовчуванням у std :: allocator буде викликати :: new ((void *) p) T (args), але спеціалізовані розподільники можуть вибрати інше визначення.

Це майже говорить нам про те, що для схеми розподілювача за замовчуванням (і, можливо, єдиної) ви повинні визначити конструктор із відповідною кількістю аргументів для того, що ви намагаєтесь замістити-побудувати у контейнер.

вам потрібно визначити конструктор для вашого типу, Tоскільки він містить std::stringнетривіальний.

крім того, було б краще визначити (можливо, за замовчуванням) переміщення ctor / assign (оскільки у вас є рухомий std::stringчлен) - це допомогло б перенести ваш Tнабагато ефективніший ...

або просто використовуйте T{...}для виклику перевантаження, emplace_back()як рекомендується у відповіді сусіда ... все залежить від типових випадків використання ...

Ви можете створити struct Tекземпляр, а потім перемістити його до вектора:

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

Ви можете використовувати {}синтаксис для ініціалізації нового елемента:

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

Це може бути оптимізовано, а може і не оптимізовано, але має бути.

Вам потрібно визначити конструктор, щоб це працювало, зауважте, що з вашим кодом ви навіть не можете зробити:

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

Але це те, що вам потрібно для роботи на місці.

так просто:

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

змусить це працювати бажаним чином.