จะบังคับใช้ความหมายการย้ายได้อย่างไรเมื่อเวกเตอร์เติบโตขึ้น

ฉันมีstd::vectorวัตถุของชั้นAหนึ่ง คลาสไม่สำคัญและมีตัวสร้างการคัดลอกและย้ายตัวสร้างที่กำหนดไว้

std::vector<A>  myvec;

ถ้าฉันเติมเวกเตอร์ด้วยAวัตถุ (โดยใช้เช่นmyvec.push_back(a)) เวกเตอร์จะมีขนาดใหญ่ขึ้นโดยใช้ตัวสร้างการคัดลอกA( const A&)เพื่อสร้างอินสแตนซ์สำเนาใหม่ขององค์ประกอบในเวกเตอร์

ฉันสามารถบังคับใช้ตัวสร้างการย้ายของคลาสAแทนได้หรือไม่?

คุณจำเป็นต้องแจ้ง c ++ (เฉพาะstd::vector) ที่คอนสตรัคย้ายและ destructor noexceptของคุณไม่ได้โยนใช้ จากนั้นตัวสร้างการย้ายจะถูกเรียกเมื่อเวกเตอร์โตขึ้น

นี่คือวิธีการประกาศและใช้ตัวกำหนดย้ายที่เคารพโดยstd::vector:

A(A && rhs) noexcept { 
  std::cout << "i am the move constr" <<std::endl;
  ... some code doing the move ...  
  m_value=std::move(rhs.m_value) ; // etc...
}

ถ้าสร้างไม่ได้noexcept, std::vectorไม่สามารถใช้งานได้ตั้งแต่นั้นมาก็ไม่สามารถให้การค้ำประกันยกเว้นเรียกร้องโดยมาตรฐาน

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่กล่าวในมาตรฐานโปรดอ่าน ความหมายและข้อยกเว้นของ C ++ Move

เครดิตโบที่บอกใบ้ว่าอาจต้องมีข้อยกเว้น พิจารณาคำแนะนำของ Kerrek SB และใช้emplace_backเมื่อเป็นไปได้ มันสามารถจะเร็วขึ้น ( แต่มักจะไม่) ก็สามารถที่ชัดเจนและมีขนาดกะทัดรัดมากขึ้น แต่ก็ยังมีบางข้อผิดพลาด (โดยเฉพาะอย่างยิ่งกับการก่อสร้างที่ไม่ชัดเจน)

แก้ไขโดยปกติค่าเริ่มต้นคือสิ่งที่คุณต้องการ: ย้ายทุกอย่างที่สามารถย้ายได้คัดลอกส่วนที่เหลือ หากต้องการขออย่างชัดเจนให้เขียน

A(A && rhs) = default;

การทำเช่นนั้นคุณจะได้รับ noexcept เมื่อเป็นไปได้: ตัวสร้าง Move เริ่มต้นถูกกำหนดให้เป็น noexcept หรือไม่?

โปรดทราบว่า Visual Studio 2015 เวอร์ชันก่อนหน้าและเก่ากว่าไม่รองรับแม้ว่าจะสนับสนุนความหมายการย้ายก็ตาม

ที่น่าสนใจ GCC 4.7.2 noexceptของเวกเตอร์เพียงใช้คอนสตรัคย้ายถ้าทั้งสองคอนสตรัคย้ายและเตาเผาที่มี ตัวอย่างง่ายๆ:

struct foo {
    foo() {}
    foo( const foo & ) noexcept { std::cout << "copy\n"; }
    foo( foo && ) noexcept { std::cout << "move\n"; }
    ~foo() noexcept {}
};

int main() {
    std::vector< foo > v;
    for ( int i = 0; i < 3; ++i ) v.emplace_back();
}

สิ่งนี้ให้ผลลัพธ์ที่คาดหวัง:

move
move
move

แต่เมื่อฉันลบnoexceptจาก~foo()ผลที่ได้จะแตกต่างกัน

copy
copy
copy

ฉันเดาว่านี่ตอบคำถามนี้ด้วย

ดูเหมือนว่าวิธีเดียว (สำหรับ C ++ 17 และก่อนหน้า) ในการบังคับstd::vectorใช้ use move semantics ในการจัดสรรใหม่คือการลบตัวสร้างการคัดลอก :) ด้วยวิธีนี้มันจะใช้ตัวสร้างการเคลื่อนไหวของคุณหรือพยายามตายในเวลารวบรวม :)

มีกฎระเบียบจำนวนมากที่มีstd::vectorไม่ต้องใช้คอนสตรัคย้ายจัดสรร แต่ไม่มีอะไรเกี่ยวกับการที่มันต้องใช้มัน

template<class T>
class move_only : public T{
public:
   move_only(){}
   move_only(const move_only&) = delete;
   move_only(move_only&&) noexcept {};
   ~move_only() noexcept {};

   using T::T;   
};

มีชีวิต

หรือ

template<class T>
struct move_only{
   T value;

   template<class Arg, class ...Args, typename = std::enable_if_t<
            !std::is_same_v<move_only<T>&&, Arg >
            && !std::is_same_v<const move_only<T>&, Arg >
    >>
   move_only(Arg&& arg, Args&&... args)
      :value(std::forward<Arg>(arg), std::forward<Args>(args)...)
   {}

   move_only(){}
   move_only(const move_only&) = delete;   
   move_only(move_only&& other) noexcept : value(std::move(other.value)) {};    
   ~move_only() noexcept {};   
};

รหัสสด

Tชั้นเรียนของคุณต้องมีตัวnoexceptดำเนินการสร้าง / ตัวดำเนินการย้ายและตัวnoexceptทำลาย มิฉะนั้นคุณจะได้รับข้อผิดพลาดในการคอมไพล์

std::vector<move_only<MyClass>> vec;