C++ Academy · บทเรียน

รีเฟอเรนซ์ Rvalue และไวยากรณ์ &&

ผูกกับค่าชั่วคราวด้วยรีเฟอเรนซ์ rvalue เพื่อถ่ายโอนทรัพยากรอย่างมีประสิทธิภาพ

บทเรียน 2 จาก 413 ขั้นตอน

รีเฟอเรนซ์ Rvalue และไวยากรณ์ && เป็นบทเรียน C++ Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C++ Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

ไวยากรณ์ &&

การอ้างอิง rvalue ประกาศด้วย T&& โดยจะผูกได้เฉพาะกับ rvalue ซึ่งเป็นค่าชั่วคราวที่กำลังจะถูกทำลาย

int&& ref = 42;          // OK: binds to literal
int x = 10;
// int&& bad = x;        // ERROR: x is an lvalue

เหตุใดจึงมีการอ้างอิง rvalue

การอ้างอิงเหล่านี้ทำให้คุณเขียนฟังก์ชันที่ ทราบว่าอาร์กิวเมนต์กำลังจะถูกทำลายได้ คุณจึงนำทรัพยากรของมันมาใช้โดยไม่ต้องคัดลอก

โอเวอร์โหลดฟังก์ชันตามชนิดการอ้างอิง

คุณสามารถโอเวอร์โหลดฟังก์ชันโดยใช้ทั้ง T& และ T&& คอมไพเลอร์จะเลือกฟังก์ชันที่เหมาะสมตามหมวดหมู่ของอาร์กิวเมนต์

void process(std::string& s) { std::cout << "lvalue\n"; }
void process(std::string&& s) { std::cout << "rvalue\n"; }

std::string s = "hi";
process(s);            // lvalue
process("temp");       // rvalue
process(std::move(s)); // rvalue

การอ้างอิง rvalue ที่มีชื่อจะกลายเป็น lvalue

เมื่อคุณตั้งชื่อให้การอ้างอิง rvalue ชื่อนั้นจะเป็น lvalue ด้วยตัวมันเอง เพราะเอกลักษณ์ของมันถูกกำหนดไว้แล้ว ให้ใช้ std::move เพื่อเปลี่ยนกลับเป็น rvalue

void f(std::string&& s) {
    // inside f, the parameter s is an lvalue
    g(s);              // passes s by lvalue
    h(std::move(s));   // passes s as an rvalue
}

std::move คือการแคสต์

std::move(x) ไม่ได้ย้ายสิ่งใดด้วยตัวเอง แต่เป็นการแคสต์ชนิดที่ส่งคืน x ในฐานะการอ้างอิง rvalue การย้ายจริงจะเกิดขึ้นในตัวสร้างที่รับค่า

// equivalent to
static_cast<std::string&&>(s)

เหตุใดจึงเรียกว่าการย้าย

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

การอ้างอิงสากล (การอ้างอิงสำหรับส่งต่อ)

เมื่อ T&& ปรากฏในแม่แบบที่มีการอนุมาน T สิ่งนี้จะเป็น การอ้างอิงสำหรับส่งต่อ ซึ่งผูกได้ทั้งกับ lvalue และ rvalue พร้อมรักษาหมวดหมู่เดิมไว้

template <typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg));
}

การยุบการอ้างอิง

เมื่อการอ้างอิงซ้อนกันผ่านแม่แบบ ภาษาโปรแกรมจะยุบการอ้างอิงเหล่านั้น:

T& & → T&
T& && → T&
T&& & → T&
T&& && → T&&

เมื่อใดไม่ควรใช้การย้าย

สำหรับชนิดที่คัดลอกได้โดยตรง (int, double, pointer) การย้ายก็เหมือนกับการคัดลอก การเรียก std::move จึงไม่ให้ประโยชน์เพิ่มเติมและอาจทำให้ผู้อ่านสับสน

การย้ายโดยไม่มีทรัพยากรที่ครอบครอง

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

ข้อควรระวังที่พบบ่อย: การย้ายจาก const

std::move กับออบเจ็กต์ const จะไม่ทำอะไร เพราะไม่สามารถเรียกตัวสร้างการย้ายกับ const ได้ เนื่องจากตัวสร้างดังกล่าวจำเป็นต้องแก้ไขต้นทาง

ตรวจสอบความเข้าใจ

std::move(x) ทำอะไรจริง ๆ

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

T&& ผูกกับ rvalue การอ้างอิง rvalue ที่มีชื่อจะกลายเป็น lvalue ให้ใช้ std::move เพื่อเปลี่ยนกลับ T&& ในแม่แบบคือการอ้างอิงสำหรับส่งต่อ std::move เป็นการแคสต์ ไม่ได้ดำเนินการย้ายด้วยตัวเอง

เริ่มต้นได้ฟรี

เรียนรู้ C++ ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 51
บทเรียน: 203

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “รีเฟอเรนซ์ Rvalue และไวยากรณ์ &&” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รีเฟอเรนซ์ Rvalue และไวยากรณ์ &&” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C++ Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “รีเฟอเรนซ์ Rvalue และไวยากรณ์ &&”

ผูกกับค่าชั่วคราวด้วยรีเฟอเรนซ์ rvalue เพื่อถ่ายโอนทรัพยากรอย่างมีประสิทธิภาพ คุณปฏิบัติ C++ Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C++ Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C++ Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “รีเฟอเรนซ์ Rvalue และไวยากรณ์ &&” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C++ Academy นี้ได้ไหม

ได้ บทเรียน C++ Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ C++ Academy