C ++ 11 emplace_back บน vector <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)... }; }
    };
}

หมายเหตุ: โครงสร้างฟังก์ชันสมาชิกที่แสดงด้านบนไม่สามารถคอมไพล์ด้วยเสียงดัง 3.1 (ขออภัยฉันไม่รู้ว่าทำไม) ลองใช้วิธีถัดไปหากคุณจะใช้ clang 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 ที่มีการจัดสรร _type เหมือนกับ A และ value_type เหมือนกับ T และกำหนดค่า lvalue m ประเภท A ตัวชี้ p ของประเภท T * นิพจน์ v ประเภท T และ rvalue rv ของประเภท T มีการกำหนดเงื่อนไขต่อไปนี้

ตอนนี้สิ่งที่ทำให้มันสร้างขึ้นเองได้:

T คือ EmplaceConstructible เป็น X จาก args สำหรับอาร์กิวเมนต์ที่เป็นศูนย์หรือมากกว่าหมายความว่านิพจน์ต่อไปนี้มีรูปแบบที่ดี: จัดสรร _traits :: สร้าง (m, p, args);

และในที่สุดก็เป็นข้อสังเกตเกี่ยวกับการใช้งานการเรียกสร้างเริ่มต้น

หมายเหตุ: คอนเทนเนอร์เรียกใช้การจัดสรร _traits :: สร้าง (m, p, args) เพื่อสร้างองค์ประกอบที่ p โดยใช้ args โครงสร้างเริ่มต้นใน std :: ตัวจัดสรรจะเรียก :: new ((void *) p) T (args) แต่ตัวจัดสรรแบบพิเศษอาจเลือกนิยามที่แตกต่างกัน

สิ่งนี้บอกเราได้อย่างดีว่าสำหรับโครงร่างตัวจัดสรรเริ่มต้น (และอาจเป็นเพียงตัวเดียว) คุณต้องกำหนดตัวสร้างด้วยจำนวนอาร์กิวเมนต์ที่เหมาะสมสำหรับสิ่งที่คุณพยายามจะฝัง - สร้างลงในคอนเทนเนอร์

คุณต้องกำหนดคอนสตรัคเตอร์สำหรับประเภทของคุณTเนื่องจากมีสิ่งstd::stringที่ไม่สำคัญ

ยิ่งไปกว่านั้นมันจะเป็นการดีกว่าที่จะกำหนด (เป็นไปได้ที่ผิดนัด) ย้าย ctor / กำหนด (เพราะคุณมีstd::stringสมาชิกที่สามารถเคลื่อนย้ายได้) ซึ่งจะช่วยให้คุณTมีประสิทธิภาพมากขึ้น ...

หรือใช้T{...}เพื่อโทรเกินemplace_back()ตามคำแนะนำในการตอบสนองของ Neighboug ... ทุกอย่างขึ้นอยู่กับกรณีการใช้งานทั่วไปของคุณ ...

คุณสามารถสร้าง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_) {}
}

จะทำให้มันทำงานได้ตามที่ต้องการ