คำตอบแรกของฉันคือการแนะนำเบื้องต้นที่ง่ายมากในการย้ายซีแมนทิกส์และรายละเอียดมากมายถูกทิ้งไว้โดยมีจุดประสงค์เพื่อให้ง่าย อย่างไรก็ตามมีมากขึ้นในการย้ายความหมายและฉันคิดว่ามันเป็นเวลาสำหรับคำตอบที่สองเพื่อเติมช่องว่าง คำตอบแรกนั้นค่อนข้างเก่าและไม่รู้สึกถูกต้องที่จะแทนที่ด้วยข้อความที่แตกต่างอย่างสิ้นเชิง ฉันคิดว่ามันยังทำหน้าที่ได้ดีเหมือนเป็นการแนะนำครั้งแรก แต่ถ้าคุณต้องการที่จะขุดลึกอ่านเพิ่มเติม :)
สเตฟานต. Lavavej ใช้เวลาในการแสดงความคิดเห็นที่มีค่า ขอบคุณมากสเตฟาน!
บทนำ
ความหมายของการย้ายช่วยให้วัตถุภายใต้เงื่อนไขบางประการเพื่อเป็นเจ้าของทรัพยากรภายนอกของวัตถุอื่น นี่เป็นสิ่งสำคัญในสองวิธี:
เปลี่ยนสำเนาที่มีราคาแพงเป็นการเคลื่อนไหวที่ราคาถูก ดูคำตอบแรกของฉันสำหรับตัวอย่าง โปรดทราบว่าหากวัตถุไม่ได้จัดการทรัพยากรภายนอกอย่างน้อยหนึ่งทรัพยากร (ไม่ว่าโดยตรงหรือโดยอ้อมผ่านวัตถุสมาชิก) ความหมายของการย้ายจะไม่มีข้อได้เปรียบใด ๆ เหนือความหมายของการคัดลอก ในกรณีนั้นการคัดลอกวัตถุและย้ายวัตถุหมายถึงสิ่งเดียวกัน:
class cannot_benefit_from_move_semantics
{
int a; // moving an int means copying an int
float b; // moving a float means copying a float
double c; // moving a double means copying a double
char d[64]; // moving a char array means copying a char array
// ...
};
การใช้ประเภท "ย้ายเท่านั้น" ที่ปลอดภัย นั่นคือชนิดที่การทำสำเนาไม่สมเหตุสมผล แต่การย้ายทำได้ ตัวอย่างเช่นการล็อกตัวจัดการไฟล์และพอยน์เตอร์อัจฉริยะที่มีซีแมนทิกส์เฉพาะ หมายเหตุ: คำตอบนี้กล่าวถึงstd::auto_ptrเทมเพลตไลบรารีมาตรฐาน C ++ 98 ที่คัดค้านซึ่งถูกแทนที่ด้วยstd::unique_ptrใน C ++ 11 โปรแกรมเมอร์ C ++ ระดับกลางอาจมีความคุ้นเคยอย่างน้อยstd::auto_ptrและเนื่องจาก "ความหมายของการย้าย" แสดงขึ้นดูเหมือนว่าเป็นจุดเริ่มต้นที่ดีสำหรับการพูดคุยความหมายของการย้ายใน C ++ 11 YMMV
การเคลื่อนไหวคืออะไร?
c ++ 98 std::auto_ptr<T>มาตรฐานมีห้องสมุดชี้สมาร์ทที่มีความหมายเป็นเจ้าของที่ไม่ซ้ำกันเรียกว่า ในกรณีที่คุณไม่คุ้นเคยauto_ptrจุดประสงค์ของมันคือเพื่อรับประกันว่าวัตถุที่จัดสรรแบบไดนามิกจะถูกปล่อยออกมาเสมอแม้ในกรณีที่มีข้อยกเว้น:
{
std::auto_ptr<Shape> a(new Triangle);
// ...
// arbitrary code, could throw exceptions
// ...
} // <--- when a goes out of scope, the triangle is deleted automatically
สิ่งผิดปกติเกี่ยวกับauto_ptrคือพฤติกรรม "คัดลอก":
auto_ptr<Shape> a(new Triangle);
+---------------+
| triangle data |
+---------------+
^
|
|
|
+-----|---+
| +-|-+ |
a | p | | | |
| +---+ |
+---------+
auto_ptr<Shape> b(a);
+---------------+
| triangle data |
+---------------+
^
|
+----------------------+
|
+---------+ +-----|---+
| +---+ | | +-|-+ |
a | p | | | b | p | | | |
| +---+ | | +---+ |
+---------+ +---------+
หมายเหตุวิธีการเริ่มต้นของการbที่มีaไม่ได้คัดลอกรูปสามเหลี่ยม แต่แทนที่จะโอนความเป็นเจ้าของของรูปสามเหลี่ยมจากไปa bนอกจากนี้เรายังพูดว่า " aถูกย้ายไปที่ b " หรือ "สามเหลี่ยมถูกย้ายจากa ไปยัง b " สิ่งนี้อาจฟังดูสับสนเนื่องจากรูปสามเหลี่ยมอยู่ในที่เดียวกันเสมอในหน่วยความจำ
ในการย้ายวัตถุหมายถึงการถ่ายโอนความเป็นเจ้าของทรัพยากรบางอย่างที่จัดการไปยังวัตถุอื่น
ตัวสร้างสำเนาของauto_ptrอาจมีลักษณะเช่นนี้ (ค่อนข้างง่าย):
auto_ptr(auto_ptr& source) // note the missing const
{
p = source.p;
source.p = 0; // now the source no longer owns the object
}
การเคลื่อนไหวที่เป็นอันตรายและไม่เป็นอันตราย
สิ่งที่อันตรายเกี่ยวกับauto_ptrคือสิ่งที่ syntactically ดูเหมือนสำเนาจริงย้าย การพยายามเรียกฟังก์ชั่นสมาชิกที่ย้ายจากมาauto_ptrจะทำให้เกิดพฤติกรรมที่ไม่ได้กำหนดดังนั้นคุณต้องระวังไม่ให้ใช้auto_ptrหลังจากที่ย้ายจาก:
auto_ptr<Shape> a(new Triangle); // create triangle
auto_ptr<Shape> b(a); // move a into b
double area = a->area(); // undefined behavior
แต่auto_ptrไม่อันตรายเสมอไป ฟังก์ชั่นจากโรงงานเป็นกรณีการใช้งานที่สมบูรณ์แบบสำหรับauto_ptr:
auto_ptr<Shape> make_triangle()
{
return auto_ptr<Shape>(new Triangle);
}
auto_ptr<Shape> c(make_triangle()); // move temporary into c
double area = make_triangle()->area(); // perfectly safe
สังเกตว่าทั้งสองตัวอย่างทำตามรูปแบบวากยสัมพันธ์เดียวกันอย่างไร:
auto_ptr<Shape> variable(expression);
double area = expression->area();
และหนึ่งในนั้นก็เรียกใช้พฤติกรรมที่ไม่ได้กำหนดในขณะที่อีกคนหนึ่งไม่ได้ ดังนั้นความแตกต่างระหว่างการแสดงออกaและmake_triangle()คืออะไร? พวกเขาทั้งสองประเภทเดียวกันไม่ได้เหรอ? อันที่จริงพวกเขามี แต่พวกเขามีความแตกต่างกันหมวดมูลค่า
หมวดหมู่ค่า
เห็นได้ชัดว่าจะต้องมีความแตกต่างอย่างลึกซึ้งระหว่างการแสดงออกaซึ่งหมายถึงauto_ptrตัวแปรและการแสดงออกmake_triangle()ซึ่งหมายถึงการเรียกใช้ฟังก์ชั่นที่ส่งกลับauto_ptrค่าโดยการสร้างauto_ptrวัตถุชั่วคราวสดทุกครั้งที่มันถูกเรียก aเป็นตัวอย่างของการเป็นนักการlvalueในขณะที่make_triangle()เป็นตัวอย่างของการเป็นนักการrvalue
การย้ายจาก lvalues เช่นเป็นaสิ่งที่อันตรายเพราะเราสามารถลองเรียกฟังก์ชันสมาชิกในภายหลังโดยaเรียกใช้พฤติกรรมที่ไม่ได้กำหนด ในทางกลับกันการย้ายจากค่าเช่นmake_triangle()มีความปลอดภัยอย่างสมบูรณ์เพราะหลังจากตัวสร้างสำเนาทำงานของมันแล้วเราไม่สามารถใช้งานชั่วคราวได้อีก ไม่มีการแสดงออกที่แสดงว่าชั่วคราว ถ้าเราเพียงแค่เขียนmake_triangle()อีกครั้งที่เราได้รับแตกต่างกันชั่วคราว ในความเป็นจริงการย้ายจากชั่วคราวไปแล้วในบรรทัดถัดไป:
auto_ptr<Shape> c(make_triangle());
^ the moved-from temporary dies right here
โปรดทราบว่าตัวอักษรlและrมีต้นกำเนิดประวัติศาสตร์ในด้านซ้ายและด้านขวามือของการมอบหมาย สิ่งนี้ไม่เป็นความจริงใน C ++ อีกต่อไปเนื่องจากมีค่าที่ไม่สามารถปรากฏทางด้านซ้ายมือของการมอบหมาย (เช่นอาร์เรย์หรือประเภทที่ผู้ใช้กำหนดเองโดยไม่มีตัวดำเนินการกำหนดค่า) และมีค่าที่สามารถ (ค่าทั้งหมดของชั้นเรียนทั้งหมด กับผู้ประกอบการที่ได้รับมอบหมาย)
rvalue ของประเภทชั้นเรียนคือการแสดงออกที่มีการประเมินผลสร้างวัตถุชั่วคราว ภายใต้สถานการณ์ปกติไม่มีนิพจน์อื่นภายในขอบเขตเดียวกันแสดงถึงวัตถุชั่วคราวเดียวกัน
การอ้างอิงค่า
ตอนนี้เราเข้าใจว่าการเคลื่อนย้ายจาก lvalues อาจเป็นอันตราย แต่การย้ายจาก rvalues นั้นไม่เป็นอันตราย หาก C ++ มีภาษารองรับเพื่อแยกความแตกต่างของข้อโต้แย้ง lvalue จากข้อโต้แย้ง rvalue เราสามารถห้ามการย้ายจาก lvalues อย่างสมบูรณ์หรืออย่างน้อยก็ทำให้การย้ายจาก lvalues ชัดเจนที่ไซต์การโทรเพื่อให้เราไม่ย้ายโดยไม่ตั้งใจอีกต่อไป
คำตอบของ C ++ 11 สำหรับปัญหานี้คือการอ้างอิงที่คุ้มค่า การอ้างอิง rvalue เป็นชนิดใหม่ของการอ้างอิงที่ผูกเท่านั้นที่จะ rvalues X&&และไวยากรณ์คือ อ้างอิงเก่าที่ดีX&เป็นที่รู้จักกันตอนนี้เป็นอ้างอิง lvalue (หมายเหตุว่าX&&เป็นไม่ได้มีการอ้างอิงถึงการอ้างอิง; ไม่มีสิ่งดังกล่าวใน C ++.)
ถ้าเราโยนconstลงไปมิกซ์เรามีการอ้างอิงสี่แบบที่ต่างกัน ประเภทของการแสดงออกประเภทใดXพวกเขาสามารถผูกกับ?
lvalue const lvalue rvalue const rvalue
---------------------------------------------------------
X& yes
const X& yes yes yes yes
X&& yes
const X&& yes yes
const X&&ในทางปฏิบัติคุณสามารถลืมเกี่ยวกับ การ จำกัด ให้อ่านจากค่า rvalues นั้นไม่มีประโยชน์มากนัก
การอ้างอิง rvalue เป็นการอ้างอิงX&&ชนิดใหม่ที่ผูกกับค่า rvalue เท่านั้น
การแปลงโดยนัย
การอ้างอิงที่คุ้มค่าผ่านหลายเวอร์ชัน ตั้งแต่รุ่น 2.1 การอ้างอิง rvalue X&&ยังผูกกับทุกประเภทมูลค่าของประเภทที่แตกต่างกันYให้มีการแปลงนัยจากการY XในกรณีดังXกล่าวจะมีการสร้างชนิดชั่วคราวและการอ้างอิง rvalue จะเชื่อมโยงกับชั่วคราว:
void some_function(std::string&& r);
some_function("hello world");
ในตัวอย่างข้างต้น"hello world"เป็น lvalue const char[12]ประเภท นับตั้งแต่มีการแปลงนัยจากconst char[12]ผ่านconst char*ไปstd::stringเป็นชั่วคราวของประเภทstd::stringจะถูกสร้างขึ้นและrถูกผูกไว้ชั่วคราวที่ นี่เป็นหนึ่งในกรณีที่ความแตกต่างระหว่าง rvalues (นิพจน์) และ tempages (วัตถุ) นั้นเบลอเล็กน้อย
ย้ายตัวสร้าง
ตัวอย่างการใช้งานของฟังก์ชั่นที่มีX&&พารามิเตอร์ที่เป็นตัวสร้างย้าย X::X(X&& source)โดยมีวัตถุประสงค์คือเพื่อโอนความเป็นเจ้าของของทรัพยากรที่มีการจัดการจากแหล่งลงในวัตถุปัจจุบัน
ใน C ++ 11 std::auto_ptr<T>ถูกแทนที่ด้วยstd::unique_ptr<T>ซึ่งใช้ประโยชน์จากการอ้างอิง rvalue unique_ptrฉันจะมีการพัฒนาและหารือฉบับง่าย อันดับแรกเราใส่แค็ปซูลตัวชี้แบบดิบและโอเวอร์โหลดตัวดำเนินการ->และ*ดังนั้นคลาสของเราจึงรู้สึกเหมือนตัวชี้:
template<typename T>
class unique_ptr
{
T* ptr;
public:
T* operator->() const
{
return ptr;
}
T& operator*() const
{
return *ptr;
}
ตัวสร้างใช้ความเป็นเจ้าของของวัตถุและ destructor ลบมัน:
explicit unique_ptr(T* p = nullptr)
{
ptr = p;
}
~unique_ptr()
{
delete ptr;
}
ตอนนี้ส่วนที่น่าสนใจผู้สร้างย้าย:
unique_ptr(unique_ptr&& source) // note the rvalue reference
{
ptr = source.ptr;
source.ptr = nullptr;
}
ตัวสร้างการย้ายนี้ทำสิ่งที่ตัวauto_ptrสร้างการคัดลอกทำ แต่สามารถให้ค่า rvalues ได้เท่านั้น:
unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a); // error
unique_ptr<Shape> c(make_triangle()); // okay
บรรทัดที่สองไม่สามารถคอมไพล์ได้เนื่องจากaเป็น lvalue แต่พารามิเตอร์unique_ptr&& sourceสามารถผูกกับ rvalues เท่านั้น ตรงนี้เป็นสิ่งที่เราต้องการ การเคลื่อนไหวที่อันตรายไม่ควรกระทำโดยปริยาย บรรทัดที่สามคอมไพล์ได้ดีเพราะmake_triangle()เป็นค่า rvalue cนวกรรมิกย้ายจะโอนกรรมสิทธิ์จากการชั่วคราว นี่คือสิ่งที่เราต้องการ
ตัวสร้างการเคลื่อนย้ายถ่ายโอนความเป็นเจ้าของของทรัพยากรที่มีการจัดการลงในวัตถุปัจจุบัน
ย้ายผู้ประกอบการที่ได้รับมอบหมาย
ชิ้นสุดท้ายที่หายไปคือผู้ประกอบการที่ได้รับมอบหมายย้าย หน้าที่คือการปล่อยทรัพยากรเก่าและรับทรัพยากรใหม่จากการโต้แย้ง:
unique_ptr& operator=(unique_ptr&& source) // note the rvalue reference
{
if (this != &source) // beware of self-assignment
{
delete ptr; // release the old resource
ptr = source.ptr; // acquire the new resource
source.ptr = nullptr;
}
return *this;
}
};
สังเกตว่าการใช้งานตัวดำเนินการกำหนดค่าการย้ายนี้ซ้ำตรรกะของทั้งตัวทำลายและตัวสร้างการย้าย คุณคุ้นเคยกับสำนวนการคัดลอกและแลกเปลี่ยนหรือไม่? นอกจากนี้ยังสามารถนำมาใช้เพื่อย้ายความหมายเป็นสำนวนการย้ายและแลกเปลี่ยน:
unique_ptr& operator=(unique_ptr source) // note the missing reference
{
std::swap(ptr, source.ptr);
return *this;
}
};
ตอนนี้sourceเป็นตัวแปรประเภทunique_ptrมันจะเริ่มต้นได้โดยตัวสร้างการย้าย; นั่นคืออาร์กิวเมนต์จะถูกย้ายไปยังพารามิเตอร์ อาร์กิวเมนต์ยังจำเป็นต้องเป็นค่า rvalue เนื่องจากตัวสร้างการย้ายเองมีพารามิเตอร์อ้างอิง rvalue เมื่อการควบคุมการไหลถึงรั้งปิดoperator=, sourceไปจากขอบเขตปล่อยทรัพยากรเก่าโดยอัตโนมัติ
ผู้ประกอบการที่ได้รับมอบหมายย้ายโอนความเป็นเจ้าของของทรัพยากรที่มีการจัดการลงในวัตถุปัจจุบันปล่อยทรัพยากรเก่า สำนวนการย้ายและสลับทำให้การใช้งานง่ายขึ้น
ย้ายจากค่า lvalues
บางครั้งเราต้องการย้ายจาก lvalues นั่นคือบางครั้งเราต้องการให้คอมไพเลอร์รักษา lvalue ราวกับว่าเป็น rvalue ดังนั้นจึงสามารถเรียกใช้ตัวสร้างการย้ายแม้ว่ามันอาจจะไม่ปลอดภัยก็ตาม เพื่อจุดประสงค์นี้, C ++ 11 ข้อเสนอฟังก์ชั่นมาตรฐานห้องสมุดแม่แบบที่เรียกว่าภายในส่วนหัวstd::move <utility>ชื่อนี้ค่อนข้างโชคร้ายเพราะstd::moveเพียงแค่ใช้ค่า lvalue กับค่า rvalue มันไม่ได้ย้ายอะไรด้วยตัวเอง มันทำให้เคลื่อนไหวได้ บางทีมันควรจะมีชื่อstd::cast_to_rvalueหรือstd::enable_moveแต่เราติดอยู่กับชื่อตอนนี้
นี่คือวิธีที่คุณย้ายจาก lvalue อย่างชัดเจน:
unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a); // still an error
unique_ptr<Shape> c(std::move(a)); // okay
โปรดทราบว่าหลังจากบรรทัดที่สามaไม่มีเจ้าของรูปสามเหลี่ยมอีกต่อไป ก็ไม่เป็นไรเพราะโดยชัดเจนเขียนstd::move(a)เราทำให้ความตั้งใจของเราที่ชัดเจน: "คอนสตรัคที่รักทำสิ่งที่คุณต้องการด้วยaเพื่อที่จะเริ่มต้นcผมไม่สนใจเกี่ยวกับaอีกต่อไปรู้สึกอิสระที่จะมีวิธีของคุณด้วย. a."
std::move(some_lvalue) ปลดล็อก lvalue ให้กับ rvalue ดังนั้นจึงทำให้สามารถเคลื่อนที่ได้ในภายหลัง
Xvalues
โปรดทราบว่าแม้ว่าจะstd::move(a)เป็นค่า rvalue การประเมินค่าจะไม่สร้างวัตถุชั่วคราว ปริศนานี้บังคับให้คณะกรรมการแนะนำหมวดหมู่คุณค่าที่สาม สิ่งที่สามารถผูกมัดกับการอ้างอิงค่า rvalue แม้ว่าจะไม่ใช่ rvalue ในความหมายดั้งเดิมเรียกว่าxvalue (eXpiring ตามตัวอักษร) ค่า rvalues ดั้งเดิมถูกเปลี่ยนชื่อเป็นprvalues (ค่า r Pure แบบบริสุทธิ์)
ทั้ง prvalues และ xvalues เป็น rvalues Xvalues และ lvalues มีทั้งglvalues (lvalues ทั่วไป) ความสัมพันธ์นั้นง่ายต่อการเข้าใจด้วยไดอะแกรม:
expressions
/ \
/ \
/ \
glvalues rvalues
/ \ / \
/ \ / \
/ \ / \
lvalues xvalues prvalues
โปรดทราบว่าเฉพาะค่า xvalues ที่เป็นจริงเท่านั้น ส่วนที่เหลือเป็นเพียงการเปลี่ยนชื่อและการจัดกลุ่ม
c ++ 98 rvalues เรียกว่า prvalues ใน C ++ 11 ทางใจแทนที่ "rvalue" ที่เกิดขึ้นทั้งหมดในย่อหน้าก่อนหน้าด้วย "prvalue"
ย้ายออกจากฟังก์ชั่น
จนถึงตอนนี้เราได้เห็นการเคลื่อนไหวในตัวแปรท้องถิ่นและเป็นพารามิเตอร์การทำงาน แต่การเคลื่อนที่ก็สามารถทำได้ในทิศทางตรงกันข้าม หากฟังก์ชันส่งคืนโดยค่าวัตถุบางอย่างที่ไซต์การโทร (อาจเป็นตัวแปรในตัวเครื่องหรือชั่วคราว แต่อาจเป็นวัตถุชนิดใดก็ได้) เริ่มต้นด้วยนิพจน์หลังจากreturnคำสั่งเป็นอาร์กิวเมนต์ไปยังตัวสร้างการย้าย:
unique_ptr<Shape> make_triangle()
{
return unique_ptr<Shape>(new Triangle);
} \-----------------------------/
|
| temporary is moved into c
|
v
unique_ptr<Shape> c(make_triangle());
บางทีน่าแปลกใจที่วัตถุอัตโนมัติ (ตัวแปรท้องถิ่นที่ไม่ได้ประกาศไว้static) สามารถย้ายออกจากฟังก์ชันโดยปริยายได้ :
unique_ptr<Shape> make_square()
{
unique_ptr<Shape> result(new Square);
return result; // note the missing std::move
}
ตัวสร้างการย้ายมาทำไมยอมรับ lvalue resultเป็นอาร์กิวเมนต์? ขอบเขตของresultกำลังจะสิ้นสุดและจะถูกทำลายระหว่างการคลายสแต็ก ไม่มีใครสามารถบ่นได้หลังจากนั้นresultมีการเปลี่ยนแปลงอย่างใด; เมื่อโฟลว์คอนโทรลกลับมาที่ผู้โทรresultไม่มีอยู่อีกต่อไป! สำหรับเหตุผลที่ C ++ 11 std::moveมีกฎพิเศษที่ช่วยให้กลับวัตถุอัตโนมัติจากฟังก์ชั่นโดยไม่ต้องเขียน ในความเป็นจริงคุณไม่ควรใช้std::moveเพื่อย้ายวัตถุอัตโนมัติออกจากฟังก์ชั่นเนื่องจากจะเป็นการยับยั้ง "การปรับค่าตอบแทนที่มีชื่อ" (NRVO)
อย่าใช้std::moveเพื่อย้ายวัตถุอัตโนมัติออกจากฟังก์ชั่น
โปรดทราบว่าในทั้งสองฟังก์ชั่นจากโรงงานชนิดส่งคืนจะเป็นค่าไม่ใช่การอ้างอิง rvalue การอ้างอิง Rvalue ยังคงเป็นการอ้างอิงและเช่นเคยคุณไม่ควรส่งคืนการอ้างอิงไปยังวัตถุอัตโนมัติ ผู้เรียกจะลงท้ายด้วยการอ้างอิงห้อยถ้าคุณหลอกให้คอมไพเลอร์ในการรับรหัสของคุณเช่นนี้
unique_ptr<Shape>&& flawed_attempt() // DO NOT DO THIS!
{
unique_ptr<Shape> very_bad_idea(new Square);
return std::move(very_bad_idea); // WRONG!
}
ไม่ส่งคืนวัตถุอัตโนมัติโดยการอ้างอิงค่า การเคลื่อนย้ายทำได้โดยตัวสร้างการย้ายเท่านั้นไม่ใช่โดยstd::moveและไม่เพียง แต่ผูกค่า rvalue กับการอ้างอิง rvalue
ย้ายเข้าเป็นสมาชิก
ไม่ช้าก็เร็วคุณจะต้องเขียนโค้ดดังนี้:
class Foo
{
unique_ptr<Shape> member;
public:
Foo(unique_ptr<Shape>&& parameter)
: member(parameter) // error
{}
};
โดยทั่วไปคอมไพเลอร์จะบ่นว่าparameterเป็น lvalue หากคุณดูประเภทของมันคุณจะเห็นการอ้างอิง rvalue แต่การอ้างอิง rvalue นั้นหมายถึง "การอ้างอิงที่ถูกผูกไว้กับ rvalue"; มันไม่ได้หมายความว่าการอ้างอิงนั้นเป็นค่าที่แท้จริง! แท้จริงแล้วparameterเป็นเพียงตัวแปรธรรมดาที่มีชื่อ คุณสามารถใช้parameterบ่อยเท่าที่คุณต้องการภายในร่างกายของนวกรรมิกและมันมักจะหมายถึงวัตถุเดียวกัน การย้ายโดยปริยายจากมันจะเป็นอันตรายดังนั้นภาษาจึงห้าม
การอ้างอิง rvalue ที่มีชื่อคือ lvalue เช่นเดียวกับตัวแปรอื่น ๆ
วิธีแก้ปัญหาคือการเปิดใช้งานการย้ายด้วยตนเอง:
class Foo
{
unique_ptr<Shape> member;
public:
Foo(unique_ptr<Shape>&& parameter)
: member(std::move(parameter)) // note the std::move
{}
};
คุณสามารถยืนยันว่าจะไม่ใช้อีกต่อไปหลังจากที่เริ่มต้นของparameter memberเหตุใดจึงไม่มีกฎพิเศษในการแทรกอย่างเงียบ ๆstd::moveเช่นเดียวกับค่าส่งคืน อาจเป็นเพราะมันจะเป็นภาระมากเกินไปในการใช้งานคอมไพเลอร์ ตัวอย่างเช่นเกิดอะไรขึ้นถ้าเนื้อความของตัวสร้างอยู่ในหน่วยการแปลอื่น ในทางกลับกันกฎคืนค่าจะต้องตรวจสอบตารางสัญลักษณ์เพื่อพิจารณาว่าตัวระบุหลังจากreturnคำหลักแสดงถึงวัตถุอัตโนมัติหรือไม่
คุณยังสามารถผ่านparameterค่า สำหรับประเภทย้ายอย่างเดียวunique_ptrดูเหมือนว่ายังไม่มีสำนวนที่สร้างไว้แล้ว โดยส่วนตัวแล้วฉันชอบที่จะส่งผ่านค่าเพราะมันทำให้เกิดความยุ่งเหยิงในอินเตอร์เฟส
ฟังก์ชั่นสมาชิกพิเศษ
C ++ 98 ประกาศหน้าที่พิเศษสมาชิกสามฟังก์ชันตามความต้องการนั่นคือเมื่อพวกเขาต้องการที่ไหนสักแห่ง: ตัวสร้างการคัดลอกตัวดำเนินการกำหนดค่าการคัดลอกและ destructor
X::X(const X&); // copy constructor
X& X::operator=(const X&); // copy assignment operator
X::~X(); // destructor
การอ้างอิงที่คุ้มค่าผ่านหลายเวอร์ชัน ตั้งแต่เวอร์ชัน 3.0, C ++ 11 ประกาศเพิ่มสมาชิกฟังก์ชันพิเศษสองตัวตามต้องการ: ตัวสร้างการย้ายและตัวดำเนินการกำหนดค่าการย้าย โปรดทราบว่าทั้ง VC10 และ VC11 นั้นไม่เป็นไปตามเวอร์ชัน 3.0 ดังนั้นคุณจะต้องใช้มันเอง
X::X(X&&); // move constructor
X& X::operator=(X&&); // move assignment operator
ฟังก์ชันพิเศษสมาชิกใหม่ทั้งสองนี้จะถูกประกาศโดยปริยายเฉพาะหากไม่มีฟังก์ชันสมาชิกพิเศษใด ๆ ที่ประกาศด้วยตนเอง นอกจากนี้หากคุณประกาศตัวสร้างการย้ายของคุณเองหรือตัวดำเนินการกำหนดย้ายตัวสร้างการคัดลอกหรือตัวดำเนินการกำหนดค่าการคัดลอกจะถูกประกาศโดยปริยาย
กฎเหล่านี้มีความหมายในทางปฏิบัติอย่างไร
ถ้าคุณเขียนคลาสโดยไม่มีทรัพยากรที่ไม่มีการจัดการคุณไม่จำเป็นต้องประกาศฟังก์ชันสมาชิกพิเศษห้ารายการด้วยตนเองและคุณจะได้รับสำเนาความหมายที่ถูกต้องและย้ายซีแมนทิกส์ฟรี มิฉะนั้นคุณจะต้องใช้ฟังก์ชั่นสมาชิกพิเศษด้วยตัวเอง แน่นอนถ้าคลาสของคุณไม่ได้รับประโยชน์จากความหมายของการย้ายคุณไม่จำเป็นต้องใช้การดำเนินการย้ายแบบพิเศษ
โปรดทราบว่าผู้ประกอบการที่ได้รับมอบหมายการคัดลอกและผู้ประกอบการได้รับมอบหมายสามารถหลอมรวมเป็นผู้ประกอบการที่ได้รับมอบหมายแบบครบวงจรเดียวรับอาร์กิวเมนต์โดยค่า:
X& X::operator=(X source) // unified assignment operator
{
swap(source); // see my first answer for an explanation
return *this;
}
ด้วยวิธีนี้จำนวนฟังก์ชั่นสมาชิกพิเศษที่จะใช้ลดลงจากห้าถึงสี่ มีข้อเสียระหว่างข้อยกเว้นด้านความปลอดภัยและประสิทธิภาพที่นี่ แต่ฉันไม่ใช่ผู้เชี่ยวชาญในเรื่องนี้
การส่งต่อการอ้างอิง ( ก่อนหน้านี้รู้จักกันในนามการอ้างอิงสากล )
พิจารณาเทมเพลตฟังก์ชันต่อไปนี้:
template<typename T>
void foo(T&&);
คุณอาจคาดว่าT&&จะผูกกับค่าเพียงเพราะอย่างรวดเร็วก่อนดูเหมือนว่าการอ้างอิงค่า ตามที่ปรากฎว่าT&&ยังผูกกับ lvalues ด้วย:
foo(make_triangle()); // T is unique_ptr<Shape>, T&& is unique_ptr<Shape>&&
unique_ptr<Shape> a(new Triangle);
foo(a); // T is unique_ptr<Shape>&, T&& is unique_ptr<Shape>&
ถ้าอาร์กิวเมนต์เป็น rvalue ประเภทX, Tจะสรุปได้ว่าจะเป็นXจึงหมายความว่าT&& X&&นี่คือสิ่งที่ทุกคนคาดหวัง แต่ถ้าอาร์กิวเมนต์เป็น lvalue ประเภทXเนื่องจากกฎพิเศษTจะสรุปได้ว่าจะเป็นX&ด้วยเหตุนี้จะหมายถึงสิ่งที่ต้องการT&& X& &&แต่เนื่องจากภาษา C ++ ยังคงมีความคิดของการอ้างอิงถึงการอ้างอิงไม่มีชนิดX& &&จะทรุดX&ลงไป สิ่งนี้อาจฟังดูสับสนและไร้ประโยชน์ในตอนแรก แต่การยุบอ้างอิงเป็นสิ่งจำเป็นสำหรับการส่งต่อที่สมบูรณ์แบบ (ซึ่งจะไม่มีการกล่าวถึงที่นี่)
T&& ไม่ใช่การอ้างอิงค่า แต่เป็นการส่งต่อการอ้างอิง นอกจากนี้ยังผูกกับ lvalues ซึ่งในกรณีนี้TและT&&เป็นการอ้างอิง lvalue ทั้งคู่
หากคุณต้องการ จำกัด แม่แบบฟังก์ชั่นเพื่อให้ค่าคุณสามารถรวมSFINAEกับลักษณะประเภท:
#include <type_traits>
template<typename T>
typename std::enable_if<std::is_rvalue_reference<T&&>::value, void>::type
foo(T&&);
การดำเนินการย้าย
หลังจากที่คุณเข้าใจการอ้างอิงแบบยุบนี่คือวิธีstd::moveการใช้งาน
template<typename T>
typename std::remove_reference<T>::type&&
move(T&& t)
{
return static_cast<typename std::remove_reference<T>::type&&>(t);
}
ตามที่คุณเห็นmoveยอมรับพารามิเตอร์ทุกชนิดด้วยการอ้างอิงการส่งต่อT&&และจะส่งคืนการอ้างอิง rvalue std::remove_reference<T>::typeโทร meta ฟังก์ชั่นเป็นสิ่งที่จำเป็นเพราะมิฉะนั้นสำหรับ lvalues ประเภทXประเภทผลตอบแทนจะเป็นซึ่งจะพังครืนลงมาX& && X&เนื่องจากtเป็น lvalue เสมอ (โปรดจำไว้ว่าการอ้างอิง rvalue ที่มีชื่อคือ lvalue) แต่เราต้องการผูกtกับการอ้างอิง rvalue เราจึงtต้องส่งกลับไปที่ประเภทการส่งคืนที่ถูกต้องอย่างชัดเจน การเรียกใช้ฟังก์ชันที่ส่งคืนการอ้างอิง rvalue นั้นคือ xvalue ตอนนี้คุณรู้แล้วว่าค่ามาจากไหน;)
การเรียกใช้ฟังก์ชันที่ส่งคืนการอ้างอิง rvalue เช่นstd::moveคือ xvalue
โปรดทราบว่าการส่งคืนโดยการอ้างอิง rvalue นั้นใช้ได้ในตัวอย่างนี้เนื่องจากtไม่ได้หมายถึงวัตถุอัตโนมัติ แต่แทนวัตถุที่ถูกส่งผ่านโดยผู้เรียกแทน