ฉันสามารถแสดงรายการ - เริ่มต้นเวกเตอร์ประเภทย้ายอย่างเดียวได้หรือไม่


98

ถ้าฉันส่งรหัสต่อไปนี้ผ่านสแนปชอต GCC 4.7 ของฉันมันจะพยายามคัดลอกunique_ptrs ลงในเวกเตอร์

#include <vector>
#include <memory>

int main() {
    using move_only = std::unique_ptr<int>;
    std::vector<move_only> v { move_only(), move_only(), move_only() };
}

เห็นได้ชัดว่าไม่สามารถทำงานได้เนื่องจากstd::unique_ptrไม่สามารถคัดลอกได้:

ข้อผิดพลาด: การใช้ฟังก์ชันที่ถูกลบ 'std :: unique_ptr <_Tp, _Dp> :: unique_ptr (const std :: unique_ptr <_Tp, _Dp> &) [ด้วย _Tp = int; _Dp = std :: default_delete; std :: unique_ptr <_Tp, _Dp> = std :: unique_ptr] '

GCC ถูกต้องในการพยายามคัดลอกตัวชี้จากรายการ initializer หรือไม่


Visual Studio และ clang มีพฤติกรรมเหมือนกัน
Jean-Simon Brochu

คำตอบ:


47

บทสรุปของ<initializer_list>ใน 18.9 ทำให้ชัดเจนพอสมควรว่าองค์ประกอบของรายการตัวเริ่มต้นจะถูกส่งผ่านทาง const-reference เสมอ น่าเสียดายที่ไม่มีวิธีใดในการใช้ move-semantic ในองค์ประกอบรายการ initializer ในการแก้ไขภาษาปัจจุบัน

โดยเฉพาะเรามี:

typedef const E& reference;
typedef const E& const_reference;

typedef const E* iterator;
typedef const E* const_iterator;

const E* begin() const noexcept; // first element
const E* end() const noexcept; // one past the last element

4
พิจารณาสำนวน <T> ที่อธิบายไว้ใน cpptruths ( cpptruths.blogspot.com/2013/09/… ) แนวคิดคือการกำหนด lvalue / rvalue ณ รันไทม์แล้วเรียกการย้ายหรือการสร้างสำเนา ใน <T> จะตรวจจับ rvalue / lvalue แม้ว่าอินเทอร์เฟซมาตรฐานที่ initializer_list ให้มาจะเป็นการอ้างอิง const
Sumant

3
@Sumant ดูเหมือนจะไม่เป็น "สำนวนสำหรับฉัน": ใช่ UB บริสุทธิ์แทนหรือไม่? ไม่ใช่แค่ตัววนซ้ำ แต่อาจเป็นองค์ประกอบพื้นฐานconstซึ่งไม่สามารถทิ้งไปในโปรแกรมที่มีรูปแบบดีได้
underscore_d

67

แก้ไข:เนื่องจาก @Johannes ดูเหมือนจะไม่ต้องการโพสต์คำตอบที่ดีที่สุดฉันก็จะทำ

#include <iterator>
#include <vector>
#include <memory>

int main(){
  using move_only = std::unique_ptr<int>;
  move_only init[] = { move_only(), move_only(), move_only() };
  std::vector<move_only> v{std::make_move_iterator(std::begin(init)),
      std::make_move_iterator(std::end(init))};
}

ตัวทำซ้ำที่ส่งคืนโดยstd::make_move_iteratorจะย้ายองค์ประกอบที่ชี้ไปที่เมื่อถูกยกเลิกการอ้างอิง


คำตอบเดิม: เราจะใช้ตัวช่วยเล็ก ๆ น้อย ๆ ที่นี่:

#include <utility>
#include <type_traits>

template<class T>
struct rref_wrapper
{ // CAUTION - very volatile, use with care
  explicit rref_wrapper(T&& v)
    : _val(std::move(v)) {}

  explicit operator T() const{
    return T{ std::move(_val) };
  }

private:
  T&& _val;
};

// only usable on temporaries
template<class T>
typename std::enable_if<
  !std::is_lvalue_reference<T>::value,
  rref_wrapper<T>
>::type rref(T&& v){
  return rref_wrapper<T>(std::move(v));
}

// lvalue reference can go away
template<class T>
void rref(T&) = delete;

น่าเสียดายที่รหัสตรงไปตรงมาใช้ไม่ได้:

std::vector<move_only> v{ rref(move_only()), rref(move_only()), rref(move_only()) };

เนื่องจากมาตรฐานไม่ว่าด้วยเหตุผลใดก็ตามไม่ได้กำหนดตัวสร้างการแปลงสำเนาเช่นนี้:

// in class initializer_list
template<class U>
initializer_list(initializer_list<U> const& other);

สิ่งที่initializer_list<rref_wrapper<move_only>>สร้างโดย brace-init-list ( {...}) จะไม่แปลงเป็นสิ่งinitializer_list<move_only>ที่vector<move_only>ใช้ ดังนั้นเราต้องมีการเริ่มต้นสองขั้นตอนที่นี่:

std::initializer_list<rref_wrapper<move_only>> il{ rref(move_only()),
                                                   rref(move_only()),
                                                   rref(move_only()) };
std::vector<move_only> v(il.begin(), il.end());

1
อ่า ... นี่คืออะนาล็อก rvalue ของstd::refไม่ใช่? บางทีมันควรจะโทรstd::rref.
Kerrek SB

19
ตอนนี้ผมคิดว่านี้ไม่ควรถูกทิ้งไว้โดยไม่ต้องถูกกล่าวถึงในความคิดเห็น move_only m[] = { move_only(), move_only(), move_only() }; std::vector<move_only> v(std::make_move_iterator(m), std::make_move_iterator(m + 3));:)
Johannes Schaub - litb

1
@ โจฮันเนส: บางครั้งมันก็เป็นวิธีง่ายๆที่ทำให้ฉันเข้าใจ แต่ผมต้องยอมรับว่าผมไม่ได้รำคาญกับผู้move_iterators เลย
Xeo

2
@ โจฮันเนส: ทำไมถึงไม่มีคำตอบล่ะ? :)
Xeo

1
@JohanLundberg: ฉันคิดว่าเป็นปัญหา QoI แต่ฉันไม่เห็นว่าทำไมมันถึงทำอย่างนั้นไม่ได้ stdlib ของ VC ++ สำหรับตัวอย่างการจัดส่งแท็กตามหมวดหมู่ตัววนซ้ำและใช้std::distanceสำหรับตัวทำซ้ำไปข้างหน้าหรือดีกว่าและstd::move_iteratorปรับหมวดหมู่ของตัววนซ้ำที่อ้างอิง อย่างไรก็ตามวิธีแก้ปัญหาที่ดีและรัดกุม โพสต์ไว้เป็นคำตอบอาจจะ?
Xeo

10

ดังที่ได้กล่าวไว้ในคำตอบอื่น ๆ ลักษณะการทำงานของstd::initializer_listคือการถือวัตถุตามมูลค่าและไม่อนุญาตให้ย้ายออกดังนั้นจึงเป็นไปไม่ได้ นี่คือวิธีแก้ปัญหาที่เป็นไปได้อย่างหนึ่งโดยใช้การเรียกใช้ฟังก์ชันที่กำหนดค่าเริ่มต้นเป็นอาร์กิวเมนต์ตัวแปร:

#include <vector>
#include <memory>

struct Foo
{
    std::unique_ptr<int> u;
    int x;
    Foo(int x = 0): x(x) {}
};

template<typename V>        // recursion-ender
void multi_emplace(std::vector<V> &vec) {}

template<typename V, typename T1, typename... Types>
void multi_emplace(std::vector<V> &vec, T1&& t1, Types&&... args)
{
    vec.emplace_back( std::move(t1) );
    multi_emplace(vec, args...);
}

int main()
{
    std::vector<Foo> foos;
    multi_emplace(foos, 1, 2, 3, 4, 5);
    multi_emplace(foos, Foo{}, Foo{});
}

น่าเสียดายที่multi_emplace(foos, {});ล้มเหลวเนื่องจากไม่สามารถอนุมานประเภทสำหรับ{}ดังนั้นสำหรับวัตถุที่จะสร้างเป็นค่าเริ่มต้นคุณต้องทำซ้ำชื่อคลาส (หรือใช้vector::resize)


4
การขยายแพ็คแบบเรียกซ้ำอาจถูกแทนที่ด้วยแฮ็คตัวดำเนินการคอมมาอาร์เรย์จำลองเพื่อบันทึกโค้ดสองสามบรรทัด
MM

1

เคล็ดลับการใช้โยฮันเน Schaub ของstd::make_move_iterator()กับstd::experimental::make_array()คุณสามารถใช้ฟังก์ชั่นการช่วยเหลือ:

#include <memory>
#include <type_traits>
#include <vector>
#include <experimental/array>

struct X {};

template<class T, std::size_t N>
auto make_vector( std::array<T,N>&& a )
    -> std::vector<T>
{
    return { std::make_move_iterator(std::begin(a)), std::make_move_iterator(std::end(a)) };
}

template<class... T>
auto make_vector( T&& ... t )
    -> std::vector<typename std::common_type<T...>::type>
{
    return make_vector( std::experimental::make_array( std::forward<T>(t)... ) );
}

int main()
{
    using UX = std::unique_ptr<X>;
    const auto a  = std::experimental::make_array( UX{}, UX{}, UX{} ); // Ok
    const auto v0 = make_vector( UX{}, UX{}, UX{} );                   // Ok
    //const auto v1 = std::vector< UX >{ UX{}, UX{}, UX{} };           // !! Error !!
}

Coliruดูมันอยู่ใน

บางทีอาจมีใครบางคนสามารถใช้std::make_array()กลอุบายของเพื่อยอมให้make_vector()ทำสิ่งนั้นได้โดยตรง แต่ฉันไม่เห็นว่า (ถูกต้องมากขึ้นฉันลองสิ่งที่ฉันคิดว่าควรได้ผลล้มเหลวและเดินหน้าต่อไป) ในกรณีใด ๆ คอมไพเลอร์จะสามารถ inline อาร์เรย์ไปสู่การเปลี่ยนแปลงเวกเตอร์เป็นเสียงดังกราวจะมี O2 GodBoltบน


-1

ตามที่ได้ระบุไว้แล้วจึงไม่สามารถเริ่มต้นเวกเตอร์ของประเภทการย้ายอย่างเดียวด้วยรายการตัวเริ่มต้นได้ โซลูชันที่เสนอโดย @Johannes เดิมใช้งานได้ดี แต่ฉันมีความคิดอื่น ... จะเกิดอะไรขึ้นถ้าเราไม่สร้างอาร์เรย์ชั่วคราวแล้วย้ายองค์ประกอบจากที่นั่นไปยังเวกเตอร์ แต่ใช้การจัดวางnewเพื่อเริ่มต้นอาร์เรย์นี้แทนที่ บล็อกหน่วยความจำของเวกเตอร์?

นี่คือฟังก์ชั่นของฉันในการเริ่มต้นเวกเตอร์ของunique_ptrโดยใช้ชุดอาร์กิวเมนต์:

#include <iostream>
#include <vector>
#include <make_unique.h>  /// @see http://stackoverflow.com/questions/7038357/make-unique-and-perfect-forwarding

template <typename T, typename... Items>
inline std::vector<std::unique_ptr<T>> make_vector_of_unique(Items&&... items) {
    typedef std::unique_ptr<T> value_type;

    // Allocate memory for all items
    std::vector<value_type> result(sizeof...(Items));

    // Initialize the array in place of allocated memory
    new (result.data()) value_type[sizeof...(Items)] {
        make_unique<typename std::remove_reference<Items>::type>(std::forward<Items>(items))...
    };
    return result;
}

int main(int, char**)
{
    auto testVector = make_vector_of_unique<int>(1,2,3);
    for (auto const &item : testVector) {
        std::cout << *item << std::endl;
    }
}

นั่นเป็นความคิดที่ผิดมหันต์ ตำแหน่งใหม่ไม่ใช่ค้อน แต่เป็นเครื่องมือที่มีความแม่นยำสูง result.data()ไม่ใช่ตัวชี้ไปยังหน่วยความจำแบบสุ่ม มันเป็นตัวชี้ไปอีกด้วยวัตถุ ลองนึกถึงสิ่งที่เกิดขึ้นกับวัตถุที่น่าสงสารนั้นเมื่อคุณวางตำแหน่งใหม่บนวัตถุนั้น
R. Martinho Fernandes

นอกจากนี้รูปแบบอาร์เรย์ของตำแหน่งใหม่ไม่สามารถใช้งานได้จริงstackoverflow.com/questions/8720425/…
R.Martinho Fernandes

@ ร. Martinho Fernandes: ขอบคุณที่ชี้ให้เห็นว่าตำแหน่งใหม่สำหรับอาร์เรย์จะไม่ทำงาน ตอนนี้ฉันเข้าใจแล้วว่าทำไมถึงเป็นความคิดที่ไม่ดี
Gart
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.