ความแตกต่างระหว่าง std :: move และ std :: forward

ฉันเห็นสิ่งนี้ที่นี่: Move Constructor โทรหา Move Constructor ระดับฐาน

มีคนอธิบายได้ไหม:

1. ความแตกต่างระหว่างstd::moveและstd::forwardโดยเฉพาะอย่างยิ่งกับตัวอย่างรหัสบางอย่าง?
2. วิธีคิดเกี่ยวกับมันง่าย ๆ และเมื่อใดควรใช้แบบไหน

std::moveใช้วัตถุและช่วยให้คุณสามารถปฏิบัติต่อมันเป็นชั่วคราว (rvalue) แม้ว่ามันจะไม่ใช่ข้อกำหนดทางความหมาย แต่โดยทั่วไปแล้วฟังก์ชั่นที่ยอมรับการอ้างอิงถึงค่า rvalue จะทำให้การใช้งานนั้นไม่ถูกต้อง เมื่อคุณเห็นstd::moveแสดงว่าไม่ควรใช้ค่าของวัตถุหลังจากนั้น แต่คุณยังสามารถกำหนดค่าใหม่และใช้งานต่อไป

std::forwardมีกรณีการใช้งานเพียงครั้งเดียว: เพื่อ cast พารามิเตอร์ฟังก์ชั่น templated (ภายในฟังก์ชั่น) กับหมวดหมู่ค่า (lvalue หรือ rvalue) โทรที่ใช้ในการส่งมัน สิ่งนี้อนุญาตให้ส่งผ่านอาร์กิวเมนต์ rvalue เป็น rvalues ​​และ lvalues ​​ถูกส่งผ่านเป็น lvalues ​​แบบแผนเรียกว่า "การส่งต่อที่สมบูรณ์แบบ"

เพื่อแสดง :

void overloaded( int const &arg ) { std::cout << "by lvalue\n"; }
void overloaded( int && arg ) { std::cout << "by rvalue\n"; }

template< typename t >
/* "t &&" with "t" being template param is special, and  adjusts "t" to be
   (for example) "int &" or non-ref "int" so std::forward knows what to do. */
void forwarding( t && arg ) {
    std::cout << "via std::forward: ";
    overloaded( std::forward< t >( arg ) );
    std::cout << "via std::move: ";
    overloaded( std::move( arg ) ); // conceptually this would invalidate arg
    std::cout << "by simple passing: ";
    overloaded( arg );
}

int main() {
    std::cout << "initial caller passes rvalue:\n";
    forwarding( 5 );
    std::cout << "initial caller passes lvalue:\n";
    int x = 5;
    forwarding( x );
}

ในขณะที่ฮาวเวิร์ดกล่าวถึงก็มีความคล้ายคลึงกันเนื่องจากฟังก์ชั่นทั้งสองนี้ใช้เพื่ออ้างอิง แต่นอกเหนือจากกรณีการใช้งานเฉพาะเหล่านี้ (ซึ่งครอบคลุมถึง 99.9% ของประโยชน์ของการอ้างอิงแบบ rvlue) คุณควรใช้static_castโดยตรงและเขียนคำอธิบายที่ดีเกี่ยวกับสิ่งที่คุณกำลังทำ

ทั้งสองstd::forwardและstd::moveไม่ได้เป็นเพียงแค่ร่าย

X x;
std::move(x);

ด้านบนปลดเปลื้องการแสดงออก lvalue xของประเภท X เพื่อการแสดงออก rvalue ของประเภท X (xvalue ที่จะต้องแน่นอน) moveยังสามารถยอมรับค่า rvalue:

std::move(make_X());

และในกรณีนี้มันเป็นฟังก์ชั่นระบุตัวตน: รับค่า rvalue ของประเภท X และส่งกลับค่า rvalue ของประเภท X

ด้วยstd::forwardคุณสามารถเลือกปลายทางได้:

X x;
std::forward<Y>(x);

ปลดล็อกนิพจน์ lvalue xของ type X ไปยังนิพจน์ประเภท Y มีข้อ จำกัด เกี่ยวกับสิ่งที่ Y สามารถเป็นได้

Y สามารถเป็นฐานของ X ที่สามารถเข้าถึงได้หรือการอ้างอิงไปยังฐานของ X. Y สามารถเป็น X หรืออ้างอิงถึง X หนึ่งไม่สามารถทิ้งตัวระบุ cv-qualifier ด้วยforwardแต่สามารถเพิ่ม cv-qualifier ได้ Y ไม่สามารถเป็นประเภทที่แปลงได้จาก X เท่านั้นยกเว้นผ่านการแปลงฐานที่สามารถเข้าถึงได้

ถ้า Y เป็นการอ้างอิง lvalue ผลลัพธ์จะเป็นนิพจน์ lvalue หาก Y ไม่ใช่การอ้างอิง lvalue ผลลัพธ์จะเป็นนิพจน์ rvalue (xvalue ที่จะแม่นยำ)

forwardสามารถรับอาร์กิวเมนต์ rvalue ก็ต่อเมื่อ Y ไม่ใช่การอ้างอิง lvalue นั่นคือคุณไม่สามารถใช้ค่า rvalue เป็น lvalue ได้ นี่คือเหตุผลด้านความปลอดภัยเนื่องจากการทำเช่นนั้นมักนำไปสู่การอ้างอิงที่ห้อยอยู่ แต่การส่งค่า rvalue ไปยัง rvalue นั้นใช้ได้และอนุญาต

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

std::forwardใช้ในการส่งต่อพารามิเตอร์ตามที่มันส่งผ่านไปยังฟังก์ชั่น เช่นเดียวกับที่แสดงที่นี่:

เมื่อใดที่จะใช้ std :: forward เพื่อส่งต่อข้อโต้แย้ง?

การใช้std::moveให้วัตถุเป็นค่า rvalue เพื่อจับคู่ตัวสร้างการย้ายหรือฟังก์ชันที่ยอมรับค่า rvalue มันทำเช่นนั้นstd::move(x)แม้ว่าxจะไม่ได้ประเมินค่าด้วยตัวเอง