C ++ 11 emplace_back trên vectơ <struct>?

Hãy xem xét chương trình sau:

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

Nó không hoạt động:

$ 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ách chính xác để làm điều này là gì và tại sao?

(Cũng đã thử dấu ngoặc đơn và kép)

Đối với bất kỳ ai từ tương lai, hành vi này sẽ được thay đổi trong C ++ 20 .

Nói cách khác, mặc dù việc triển khai nội bộ vẫn T(arg0, arg1, ...)sẽ được gọi là nó sẽ được coi là thường xuyên T{arg0, arg1, ...}mà bạn mong đợi.

Bạn cần xác định rõ ràng một ctor cho lớp:

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

Mục đích của việc sử dụng emplace_backlà tránh tạo một đối tượng tạm thời, đối tượng này sau đó được sao chép (hoặc di chuyển) đến đích. Mặc dù cũng có thể tạo một đối tượng tạm thời, sau đó chuyển đối tượng đó sang emplace_back, nhưng nó sẽ đánh bại (ít nhất là hầu hết) mục đích. Những gì bạn muốn làm là chuyển các đối số riêng lẻ, sau đó cho phép emplace_backgọi ctor với các đối số đó để tạo đối tượng tại chỗ.

Tất nhiên, đây không phải là một câu trả lời, nhưng nó cho thấy một tính năng thú vị của bộ giá trị:

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

Nếu bạn không muốn (hoặc không thể) thêm một hàm tạo, hãy chuyên biệt hóa bộ cấp phát cho T (hoặc tạo một bộ cấp phát của riêng bạn).

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

Lưu ý: Cấu trúc hàm thành viên hiển thị ở trên không thể biên dịch với clang 3.1 (Xin lỗi, tôi không biết tại sao). Hãy thử cách tiếp theo nếu bạn sử dụng clang 3.1 (hoặc các lý do khác).

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

Điều này dường như được đề cập trong 23.2.1 / 13.

Đầu tiên, định nghĩa:

Cho một loại vùng chứa X có kiểu cấp phát giống với A và kiểu giá trị giống với T và được cung cấp giá trị m thuộc kiểu A, con trỏ p kiểu T *, biểu thức v thuộc kiểu T và giá trị rv thuộc kiểu T, các thuật ngữ sau được xác định.

Bây giờ, điều gì làm cho nó có thể xây dựng được:

T là EmplaceConstructible thành X từ args, đối với không hoặc nhiều đối số args, có nghĩa là biểu thức sau được định dạng tốt: certator_traits :: construct (m, p, args);

Và cuối cùng là một lưu ý về việc triển khai mặc định của lệnh gọi cấu trúc:

Lưu ý: Một vùng chứa gọi phân bổ phân bổ_traits :: construct (m, p, args) để xây dựng một phần tử tại p bằng cách sử dụng args. Cấu trúc mặc định trong std :: phân bổ sẽ gọi :: new ((void *) p) T (args), nhưng các trình cấp phát chuyên biệt có thể chọn một định nghĩa khác.

Điều này cho chúng ta biết khá nhiều rằng đối với một lược đồ trình cấp phát mặc định (và có thể là duy nhất), bạn phải xác định một hàm tạo với số lượng đối số thích hợp cho thứ mà bạn đang cố gắng cho phép xây dựng vào một vùng chứa.

bạn phải xác định một phương thức khởi tạo cho kiểu của bạn Tvì nó chứa một phương thức std::stringkhông tầm thường.

hơn nữa, sẽ tốt hơn nếu xác định (có thể mặc định) di chuyển ctor / gán (vì bạn có một std::stringthành viên có thể di chuyển ) - điều này sẽ giúp di chuyển của bạn Thiệu quả hơn nhiều ...

hoặc, chỉ sử dụng T{...}để gọi quá tải emplace_back()như được khuyến nghị trong phản hồi hàng xóm ... mọi thứ phụ thuộc vào các trường hợp sử dụng điển hình của bạn ...

Bạn có thể tạo struct Tphiên bản và sau đó di chuyển nó vào vector:

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

Bạn có thể sử dụng {}cú pháp để khởi tạo phần tử mới:

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

Điều này có thể được tối ưu hóa hoặc không, nhưng nó nên được.

Bạn phải xác định một hàm tạo để điều này hoạt động, lưu ý rằng với mã của bạn, bạn thậm chí không thể làm được:

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

Nhưng đây là những gì bạn cần để có công việc thay thế.

vì vậy chỉ cần:

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

sẽ làm cho nó hoạt động theo cách mong muốn.