ทำไมฉันถึงต้องใช้ push_back แทน emplace_back

C ++ 11 emplace_backเวกเตอร์ที่มีฟังก์ชั่นใหม่ ซึ่งแตกต่างจากpush_backอาศัยการเพิ่มประสิทธิภาพของคอมไพเลอร์เพื่อหลีกเลี่ยงการคัดลอกemplace_backใช้การส่งต่อที่สมบูรณ์แบบเพื่อส่งข้อโต้แย้งโดยตรงไปที่นวกรรมิกเพื่อสร้างวัตถุในสถานที่ ดูเหมือนว่าฉันemplace_backจะทำทุกอย่างpush_backได้ แต่บางครั้งมันก็ทำได้ดีกว่า (แต่ไม่เคยแย่ลง)

ฉันต้องใช้เหตุผลpush_backอะไร

ฉันคิดถึงคำถามนี้ในช่วงสี่ปีที่ผ่านมา ฉันได้ข้อสรุปว่าคำอธิบายส่วนใหญ่เกี่ยวpush_backกับ vs. emplace_backคิดถึงภาพเต็ม

ปีที่แล้วผมได้นำเสนอที่ C ++ ตอนนี้ในประเภทหักใน C ฉันเริ่มพูดถึงpush_backvs. emplace_backที่ 13:49 แต่มีข้อมูลที่เป็นประโยชน์ที่ให้หลักฐานสนับสนุนก่อนหน้านั้น

ความแตกต่างหลักที่แท้จริงเกี่ยวข้องกับตัวสร้างโดยนัยกับตัวสร้างที่ชัดเจน พิจารณากรณีที่เรามีอาร์กิวเมนต์เดียวที่เราต้องการส่งต่อไปหรือpush_backemplace_back

std::vector<T> v;
v.push_back(x);
v.emplace_back(x);

หลังจากคอมไพเลอร์การปรับให้เหมาะสมของคุณได้รับสิ่งนี้แล้วไม่มีความแตกต่างระหว่างสองข้อความนี้ในแง่ของโค้ดที่สร้างขึ้น ภูมิปัญญาดั้งเดิมคือว่าpush_backจะสร้างวัตถุชั่วคราวซึ่งจะถูกย้ายเข้าไปvในขณะที่emplace_backจะส่งต่อการโต้เถียงตามและสร้างมันโดยตรงในสถานที่โดยไม่มีการคัดลอกหรือย้าย สิ่งนี้อาจเป็นจริงตามรหัสที่เขียนในไลบรารีมาตรฐาน แต่มันทำให้เข้าใจผิดว่างานเพิ่มประสิทธิภาพของคอมไพเลอร์คือการสร้างรหัสที่คุณเขียน การเพิ่มประสิทธิภาพของคอมไพเลอร์คือการสร้างรหัสที่คุณจะเขียนถ้าคุณเป็นผู้เชี่ยวชาญในการปรับแต่งเฉพาะแพลตฟอร์มและไม่สนใจเกี่ยวกับความสามารถในการบำรุงรักษาเพียงประสิทธิภาพ

ความแตกต่างที่เกิดขึ้นจริงระหว่างข้อความทั้งสองนี้คือยิ่งมีพลังมากขึ้นemplace_backจะเรียกใช้ตัวสร้างประเภทใดก็ได้ในขณะที่ความระมัดระวังยิ่งกว่าpush_backจะเรียกเฉพาะตัวสร้างที่มีนัยเท่านั้น Constructor โดยปริยายน่าจะปลอดภัย หากคุณสามารถสร้าง a Uจากโดยปริยายได้Tคุณกำลังบอกว่าUสามารถเก็บข้อมูลทั้งหมดไว้ได้Tโดยไม่มีการสูญเสีย มีความปลอดภัยในทุกสถานการณ์ที่จะผ่านTและไม่มีใครจะรังเกียจถ้าคุณทำให้มันเป็นUแทน เป็นตัวอย่างที่ดีของตัวสร้างโดยนัยคือการแปลงจากไปstd::uint32_t std::uint64_tเป็นตัวอย่างที่ไม่ดีของการแปลงนัยคือการdoublestd::uint8_t

เราต้องการที่จะระมัดระวังในการเขียนโปรแกรมของเรา เราไม่ต้องการที่จะใช้คุณสมบัติที่มีประสิทธิภาพเพราะยิ่งคุณสมบัติมีประสิทธิภาพมากขึ้นเท่าไหร่ก็จะยิ่งทำสิ่งที่ไม่ถูกต้องหรือไม่คาดคิดได้ง่ายขึ้นเท่านั้น emplace_backถ้าคุณตั้งใจจะโทรก่อสร้างอย่างชัดเจนแล้วคุณจำเป็นต้องใช้พลังงานของ push_backหากคุณต้องการที่จะเรียกก่อสร้างเพียงส่อติดกับความปลอดภัยของ

ตัวอย่าง

std::vector<std::unique_ptr<T>> v;
T a;
v.emplace_back(std::addressof(a)); // compiles
v.push_back(std::addressof(a)); // fails to compile

std::unique_ptr<T>T *มีคอนสตรัคอย่างชัดเจนจาก เพราะemplace_backสามารถเรียกคอนสตรัคเตอร์ที่ชัดเจนผ่านการคอมไพล์พอยน์เตอร์ที่ไม่ได้เป็นเจ้าของได้ดี อย่างไรก็ตามเมื่อvออกไปนอกขอบเขต destructor จะพยายามโทรหาdeleteตัวชี้นั้นซึ่งไม่ได้ถูกจัดสรรโดยnewเพราะมันเป็นเพียงวัตถุสแต็ก สิ่งนี้นำไปสู่พฤติกรรมที่ไม่ได้กำหนด

นี่ไม่ใช่แค่รหัสที่คิดค้น นี่เป็นข้อผิดพลาดการผลิตจริงที่ฉันพบ รหัสคือstd::vector<T *>แต่มันเป็นเจ้าของเนื้อหา ในฐานะที่เป็นส่วนหนึ่งของการโยกย้ายไปยัง C ++ 11 ผมอย่างถูกต้องเปลี่ยนแปลงT *เพื่อstd::unique_ptr<T>ที่จะแสดงให้เห็นว่าเวกเตอร์ที่เป็นเจ้าของหน่วยความจำ แต่ผมก็ basing การเปลี่ยนแปลงเหล่านี้ออกจากความเข้าใจของฉันในปี 2012 ในระหว่างที่ผมคิดว่า "ทุกอย่างไม่ emplace_back push_back สามารถทำและอื่น ๆ ดังนั้นทำไมฉันจะเคยใช้ push_back?" ดังนั้นผมก็เปลี่ยนไปpush_backemplace_back

หากฉันทิ้งรหัสไว้เป็นการใช้ที่ปลอดภัยกว่าpush_backฉันจะจับข้อผิดพลาดอันยาวนานนี้ได้ทันทีและจะถูกมองว่าเป็นความสำเร็จในการอัปเกรดเป็น C ++ 11 แต่ฉันปิดบังข้อบกพร่องและไม่พบมันจนกว่าจะถึงเดือนต่อมา

push_backอนุญาตให้ใช้การกำหนดค่าเริ่มต้นเสมอซึ่งฉันชอบมาก ตัวอย่างเช่น

struct aggregate {
    int foo;
    int bar;
};

std::vector<aggregate> v;
v.push_back({ 42, 121 });

ในทางกลับกันv.emplace_back({ 42, 121 });จะไม่ทำงาน

ความเข้ากันได้ย้อนหลังกับคอมไพเลอร์ pre-C ++ 11

การใช้งานไลบรารีบางส่วนของ emplace_back ไม่ได้ทำงานตามที่ระบุในมาตรฐาน C ++ รวมถึงรุ่นที่จัดส่งกับ Visual Studio 2012, 2013 และ 2015

เพื่อรองรับข้อบกพร่องของคอมไพเลอร์ที่รู้จักให้ใช้std::vector::push_back()ถ้าพารามิเตอร์อ้างอิงตัววนซ้ำหรือวัตถุอื่น ๆ ซึ่งจะไม่ถูกต้องหลังจากการโทร

std::vector<int> v;
v.emplace_back(123);
v.emplace_back(v[0]); // Produces incorrect results in some compilers

ในคอมไพเลอร์ตัวเดียว v มีค่า 123 และ 21 แทนค่าคาดหวัง 123 และ 123 เนื่องจากนี่เป็นความจริงที่ว่าการเรียกครั้งที่ 2 เพื่อให้emplace_backผลลัพธ์มีขนาดที่จุดใดv[0]ไม่ถูกต้อง

การใช้งานโค้ดด้านบนจะใช้งานpush_back()แทนemplace_back()ดังนี้:

std::vector<int> v;
v.emplace_back(123);
v.push_back(v[0]);

หมายเหตุ: การใช้เวกเตอร์ของ ints มีวัตถุประสงค์เพื่อสาธิต ฉันค้นพบปัญหานี้ด้วยคลาสที่ซับซ้อนมากขึ้นซึ่งรวมถึงตัวแปรสมาชิกที่จัดสรรแบบไดนามิกและการเรียกร้องให้emplace_back()เกิดความผิดพลาดอย่างหนัก