Std :: move ve std :: forward arasındaki fark nedir

Bunu burada gördüm: Base-class Move Constructor'ı çağıran Move Constructor

Birisi açıklayabilir mi:

1. std::moveve std::forwardtercihen bazı kod örnekleri arasındaki fark nedir?
2. Kolayca nasıl düşünülür ve ne zaman kullanılır

std::movebir nesneyi alır ve ona geçici (bir değer) olarak davranmanızı sağlar. Anlamsal bir gereklilik olmamakla birlikte, genellikle bir rvalue referansını kabul eden bir işlev, onu geçersiz kılar. Gördüğünüzde std::move, nesnenin değerinin daha sonra kullanılmaması gerektiğini gösterir, ancak yine de yeni bir değer atayabilir ve kullanmaya devam edebilirsiniz.

std::forwardtek kullanımlık bir duruma sahiptir: geçici bir işlev parametresini (işlevin içinde), arayanın iletmek için kullandığı değer kategorisine (değer veya rvalue) atamak. Bu, rvalue argümanlarının rvalue olarak iletilmesine ve lvalues ​​lvalues ​​olarak iletilmesine izin verir, bu da "mükemmel yönlendirme" adı verilen bir şemadır.

To göstermektedir :

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 );
}

Howard'ın bahsettiği gibi, her iki fonksiyon da sadece referans tipine atıldığından benzerlikler de vardır. Ancak bu özel kullanım durumlarının dışında (rvalue referans dökümlerinin kullanışlılığının% 99,9'unu kapsar), static_castdoğrudan kullanmalı ve ne yaptığınıza dair iyi bir açıklama yazmalısınız.

Hem std::forwardve std::movebaşka bir şey yayınları bulunmaktadır.

X x;
std::move(x);

Yukarıda xX tipi lvalue ifadesi X tipi bir rvalue ifadesine (tam olarak bir xvalue) verilir. moveayrıca bir rvalue kabul edebilir:

std::move(make_X());

ve bu durumda bir kimlik fonksiyonudur: X tipi bir değer alır ve X tipi bir değer döndürür.

İle std::forwardhedefi bir dereceye kadar seçebilirsiniz:

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

xX türünün lvalue ifadesini Y türündeki bir ifadeye çevirir . Y'nin ne olabileceği konusunda kısıtlamalar vardır.

Y erişilebilir bir X Tabanı veya X Tabanı referansı olabilir. Y X veya X referansı olabilir. forward . Y, erişilebilir bir Taban dönüşümü dışında X'ten dönüştürülebilen bir tür olamaz.

Y bir değer değeri referansıysa, sonuç bir değer değeri ifadesi olacaktır. Y bir değer değeri başvurusu değilse, sonuç bir değer (kesin olacak x değeri) ifadesi olur.

forwardrvalue bağımsız değişkenini yalnızca Y bir lvalue referansı değilse alabilir. Yani, değer için bir değer atayamazsınız. Bu, güvenlik nedenlerinden ötürü yaygın bir şekilde yapılması, sallanan referanslara yol açmaktadır. Ancak bir rvalue'yu rvalue'ya dökmek tamamdır ve izin verilir.

İzin verilmeyen bir şeye Y belirtmeye çalışırsanız, hata çalışma zamanında değil derleme zamanında yakalanır.

std::forwardbir parametreyi tam olarak bir işleve geçirildiği şekilde iletmek için kullanılır . Tıpkı burada gösterildiği gibi:

Bağımsız değişkenleri iletmek için std :: forward ne zaman kullanılır?

Kullanmak std::movebir nesneyi, bir hareket yapıcısı veya değer kabul eden bir işlevle eşleştirmek için bir değer olarak sunar. Tek başına bir değer olmasa std::move(x)bile bunu yapar x.