Apa itu std :: move (), dan kapan itu harus digunakan?

1. Apa itu?
2. Apa fungsinya?
3. Kapan itu harus digunakan?

Tautan yang baik dihargai.

Halaman Wikipedia di C ++ 11 Referensi nilai-R dan pindahkan konstruktor

1. Di C ++ 11, selain menyalin konstruktor, objek dapat memindahkan konstruktor.
   (Dan selain menyalin operator penugasan, mereka memiliki operator penugasan pindah.)
2. Konstruktor bergerak digunakan sebagai pengganti konstruktor salin, jika objek memiliki tipe "rvalue-reference" ( Type &&).
3. std::move() adalah para pemeran yang menghasilkan referensi-nilai-nilai ke suatu objek, untuk memungkinkan perpindahan darinya.

Ini adalah cara C ++ baru untuk menghindari salinan. Sebagai contoh, menggunakan move constructor, a std::vectorbisa saja menyalin pointer internal ke data ke objek baru, meninggalkan objek yang dipindahkan dalam keadaan dipindahkan dari keadaan, karena itu tidak menyalin semua data. Ini akan menjadi C ++ - valid.

Coba googling untuk memindahkan semantik, menilai ulang, penerusan sempurna.

1. "Apa itu?"

Sementara std::move() secara teknis fungsi - saya akan mengatakan tidak benar-benar fungsi . Ini semacam konverter antara cara kompiler mempertimbangkan nilai ekspresi.

2. "Apa fungsinya?"

Hal pertama yang perlu diperhatikan adalah std::move() tidak benar-benar memindahkan apa pun . Itu mengkonversi ekspresi dari menjadi nilai (seperti variabel bernama) menjadi nilai x . Nilai x memberi tahu kompilator:

Anda dapat menjarah saya, memindahkan apa pun yang saya pegang dan menggunakannya di tempat lain (karena bagaimanapun saya akan segera dihancurkan) ".

dengan kata lain, saat Anda menggunakan std::move(x), Anda mengizinkan penyusun mengkalibkan x. Jadi jika xmemiliki, katakanlah, buffernya sendiri dalam memori - setelah std::move()kompiler dapat memiliki objek lain memilikinya.

_{Anda juga dapat beralih dari nilai awal (seperti sementara yang Anda lewati), tetapi ini jarang berguna.}

3. "Kapan itu harus digunakan?"

Cara lain untuk mengajukan pertanyaan ini adalah "Untuk apa saya bisa mematikan sumber daya objek yang ada?" baik, jika Anda menulis kode aplikasi, Anda mungkin tidak akan main-main dengan benda-benda sementara yang dibuat oleh kompiler. Jadi terutama Anda akan melakukan ini di tempat-tempat seperti konstruktor, metode operator, fungsi standar-perpustakaan-seperti algoritma dll. Di mana objek bisa dibuat dan dihancurkan secara otomatis banyak. Tentu saja, itu hanya aturan praktis.

Penggunaan tipikal adalah memindahkan sumber daya dari satu objek ke objek lain alih-alih menyalin. @Guillaume menghubungkan ke halaman ini yang memiliki contoh singkat langsung: menukar dua objek dengan sedikit penyalinan.

template <class T>
swap(T& a, T& b) {
    T tmp(a);   // we now have two copies of a
    a = b;      // we now have two copies of b (+ discarded a copy of a)
    b = tmp;    // we now have two copies of tmp (+ discarded a copy of b)
}

menggunakan gerakan memungkinkan Anda untuk menukar sumber daya alih-alih menyalinnya:

template <class T>
swap(T& a, T& b) {
    T tmp(std::move(a));
    a = std::move(b);   
    b = std::move(tmp);
}

Pikirkan apa yang terjadi ketika T, katakanlah, vector<int>ukuran n. Pada versi pertama Anda membaca dan menulis elemen 3 * n, pada versi kedua Anda pada dasarnya membaca dan menulis hanya 3 pointer ke buffer vektor, ditambah ukuran 3 buffer. Tentu saja, kelas Tperlu tahu bagaimana melakukan gerakan; kelas Anda harus memiliki operator penugasan bergerak dan konstruktor gerakan agar kelas Tdapat berfungsi.

Anda dapat menggunakan langkah ketika Anda perlu "mentransfer" konten suatu objek di tempat lain, tanpa melakukan salinan (yaitu konten tidak digandakan, itu sebabnya dapat digunakan pada beberapa objek yang tidak dapat disalin, seperti unique_ptr). Itu juga mungkin bagi suatu objek untuk mengambil konten dari objek sementara tanpa melakukan salinan (dan menghemat banyak waktu), dengan std :: move.

Tautan ini sangat membantu saya:

http://thbecker.net/articles/rvalue_references/section_01.html

Maaf jika jawaban saya terlambat, tetapi saya juga mencari tautan yang bagus untuk std :: move, dan saya menemukan tautan di atas sedikit "keras".

Ini memberi penekanan pada referensi nilai-r, di mana konteks Anda harus menggunakannya, dan saya pikir itu lebih rinci, itu sebabnya saya ingin berbagi tautan ini di sini.

T: Apa itu std::move?

A: std::move()adalah fungsi dari C ++ Standard Library untuk casting ke referensi nilai.

Secara sederhana std::move(t)setara dengan:

static_cast<T&&>(t);

Nilai adalah sementara yang tidak bertahan di luar ekspresi yang mendefinisikannya, seperti hasil fungsi antara yang tidak pernah disimpan dalam variabel.

int a = 3; // 3 is a rvalue, does not exist after expression is evaluated
int b = a; // a is a lvalue, keeps existing after expression is evaluated

Implementasi untuk std :: move () diberikan di N2027: "Pengantar Singkat untuk Referensi Nilai" sebagai berikut:

template <class T>
typename remove_reference<T>::type&&
std::move(T&& a)
{
    return a;
}

Seperti yang Anda lihat, std::movemengembalikan T&&tidak masalah jika dipanggil dengan nilai ( T), tipe referensi (T& ) atau referensi nilai ( T&&).

T: Apa fungsinya?

A: Sebagai pemain, itu tidak melakukan apa pun selama runtime. Hanya relevan pada waktu kompilasi untuk memberi tahu kompiler bahwa Anda ingin terus mempertimbangkan referensi sebagai nilai.

foo(3 * 5); // obviously, you are calling foo with a temporary (rvalue)

int a = 3 * 5;
foo(a);     // how to tell the compiler to treat `a` as an rvalue?
foo(std::move(a)); // will call `foo(int&& a)` rather than `foo(int a)` or `foo(int& a)`

Apa yang tidak dilakukannya:

• Buat salinan argumennya
• Hubungi pembuat salinan
• Ubah objek argumen

T: Kapan harus digunakan?

A: Anda harus menggunakan std::move jika Anda ingin memanggil fungsi yang mendukung pemindahan semantik dengan argumen yang bukan nilai (ekspresi sementara).

Ini menimbulkan pertanyaan lanjutan bagi saya:

• Apa itu semantik bergerak? Memindahkan semantik berbeda dengan menyalin semantik adalah teknik pemrograman di mana anggota objek diinisialisasi dengan 'mengambil alih' alih-alih menyalin anggota objek lain. 'Pengambilalihan' semacam itu hanya masuk akal dengan pointer dan pegangan sumber daya, yang dapat ditransfer dengan murah dengan menyalin pointer atau pegangan integer daripada data yang mendasarinya.

• Kelas dan objek apa yang mendukung semantik bergerak? Terserah Anda sebagai pengembang untuk menerapkan semantik bergerak di kelas Anda sendiri jika ini akan mendapat manfaat dengan mentransfer anggota mereka daripada menyalinnya. Setelah Anda menerapkan pemindahan semantik, Anda akan langsung mendapat manfaat dari pekerjaan dari banyak pemrogram perpustakaan yang telah menambahkan dukungan untuk menangani kelas dengan pemindahan semantik secara efisien.

• Mengapa kompiler tidak dapat mengetahuinya sendiri? Kompiler tidak bisa begitu saja memanggil kelebihan fungsi yang lain kecuali Anda mengatakannya. Anda harus membantu kompilator memilih apakah versi fungsi biasa atau pindah harus dipanggil.

• Dalam situasi apa saya ingin memberitahu kompiler bahwa ia harus memperlakukan variabel sebagai nilai? Ini kemungkinan besar akan terjadi dalam fungsi templat atau pustaka, di mana Anda tahu bahwa hasil peralihan dapat diselamatkan.

std :: move itu sendiri tidak banyak membantu. Saya berpikir bahwa itu disebut konstruktor bergerak untuk objek, tetapi itu benar-benar hanya melakukan tipe casting (casting variabel lvalue ke rvalue sehingga variabel tersebut dapat diteruskan sebagai argumen ke konstruktor bergerak atau operator penugasan).

Jadi std :: move hanya digunakan sebagai prekursor untuk menggunakan semantik bergerak. Pindah semantik pada dasarnya adalah cara yang efisien untuk berurusan dengan benda-benda sementara.

Pertimbangkan Objek A = B + C + D + E + F;

Ini adalah kode yang terlihat bagus, tetapi E + F menghasilkan objek sementara. Kemudian D + temp menghasilkan objek sementara lainnya dan seterusnya. Di setiap operator "+" normal suatu kelas, salinan dalam terjadi.

Sebagai contoh

Object Object::operator+ (const Object& rhs) {
    Object temp (*this);
    // logic for adding
    return temp;
}

Penciptaan objek sementara dalam fungsi ini tidak berguna - objek sementara ini akan dihapus pada akhir baris karena mereka keluar dari ruang lingkup.

Kita bisa menggunakan move semantik untuk "menjarah" objek sementara dan melakukan sesuatu seperti

 Object& Object::operator+ (Object&& rhs) {
     // logic to modify rhs directly
     return rhs;
 }

Ini menghindari salinan dalam yang tidak perlu dibuat. Dengan mengacu pada contoh, satu-satunya bagian di mana penyalinan dalam terjadi sekarang E + F. Sisanya menggunakan semantik bergerak. Konstruktor bergerak atau operator penugasan juga perlu diimplementasikan untuk menetapkan hasilnya ke A.

"Apa itu?" dan "Apa fungsinya?" telah dijelaskan di atas.

Saya akan memberikan contoh "kapan harus digunakan".

Sebagai contoh, kami memiliki kelas dengan banyak sumber daya seperti array besar di dalamnya.

class ResHeavy{ //  ResHeavy means heavy resource
    public:
        ResHeavy(int len=10):_upInt(new int[len]),_len(len){
            cout<<"default ctor"<<endl;
        }

        ResHeavy(const ResHeavy& rhs):_upInt(new int[rhs._len]),_len(rhs._len){
            cout<<"copy ctor"<<endl;
        }

        ResHeavy& operator=(const ResHeavy& rhs){
            _upInt.reset(new int[rhs._len]);
            _len = rhs._len;
            cout<<"operator= ctor"<<endl;
        }

        ResHeavy(ResHeavy&& rhs){
            _upInt = std::move(rhs._upInt);
            _len = rhs._len;
            rhs._len = 0;
            cout<<"move ctor"<<endl;
        }

    // check array valid
    bool is_up_valid(){
        return _upInt != nullptr;
    }

    private:
        std::unique_ptr<int[]> _upInt; // heavy array resource
        int _len; // length of int array
};

Kode uji:

void test_std_move2(){
    ResHeavy rh; // only one int[]
    // operator rh

    // after some operator of rh, it becomes no-use
    // transform it to other object
    ResHeavy rh2 = std::move(rh); // rh becomes invalid

    // show rh, rh2 it valid
    if(rh.is_up_valid())
        cout<<"rh valid"<<endl;
    else
        cout<<"rh invalid"<<endl;

    if(rh2.is_up_valid())
        cout<<"rh2 valid"<<endl;
    else
        cout<<"rh2 invalid"<<endl;

    // new ResHeavy object, created by copy ctor
    ResHeavy rh3(rh2);  // two copy of int[]

    if(rh3.is_up_valid())
        cout<<"rh3 valid"<<endl;
    else
        cout<<"rh3 invalid"<<endl;
}

Output seperti di bawah ini:

default ctor
move ctor
rh invalid
rh2 valid
copy ctor
rh3 valid

Kita dapat melihat bahwa std::movedengan move constructormembuat transformasi sumber daya dengan mudah.

Di mana lagi yang std::moveberguna?

std::movejuga bisa berguna saat menyortir berbagai elemen. Banyak algoritme pengurutan (seperti sortasi pemilihan dan sortir gelembung) bekerja dengan menukar pasangan elemen. Sebelumnya, kami harus menggunakan copy-semantik untuk bertukar. Sekarang kita dapat menggunakan semantik bergerak, yang lebih efisien.

Ini juga bisa berguna jika kita ingin memindahkan konten yang dikelola oleh satu penunjuk pintar ke yang lain.

Dikutip:

• https://www.learncpp.com/cpp-tutorial/15-4-stdmove/

Berikut adalah contoh lengkap, menggunakan std :: move untuk vektor kustom (sederhana)

Output yang diharapkan:

 c: [10][11]
 copy ctor called
 copy of c: [10][11]
 move ctor called
 moved c: [10][11]

Kompilasi sebagai:

  g++ -std=c++2a -O2 -Wall -pedantic foo.cpp

Kode:

#include <iostream>
#include <algorithm>

template<class T> class MyVector {
private:
    T *data;
    size_t maxlen;
    size_t currlen;
public:
    MyVector<T> () : data (nullptr), maxlen(0), currlen(0) { }
    MyVector<T> (int maxlen) : data (new T [maxlen]), maxlen(maxlen), currlen(0) { }

    MyVector<T> (const MyVector& o) {
        std::cout << "copy ctor called" << std::endl;
        data = new T [o.maxlen];
        maxlen = o.maxlen;
        currlen = o.currlen;
        std::copy(o.data, o.data + o.maxlen, data);
    }

    MyVector<T> (const MyVector<T>&& o) {
        std::cout << "move ctor called" << std::endl;
        data = o.data;
        maxlen = o.maxlen;
        currlen = o.currlen;
    }

    void push_back (const T& i) {
        if (currlen >= maxlen) {
            maxlen *= 2;
            auto newdata = new T [maxlen];
            std::copy(data, data + currlen, newdata);
            if (data) {
                delete[] data;
            }
            data = newdata;
        }
        data[currlen++] = i;
    }

    friend std::ostream& operator<<(std::ostream &os, const MyVector<T>& o) {
        auto s = o.data;
        auto e = o.data + o.currlen;;
        while (s < e) {
            os << "[" << *s << "]";
            s++;
        }
        return os;
    }
};

int main() {
    auto c = new MyVector<int>(1);
    c->push_back(10);
    c->push_back(11);
    std::cout << "c: " << *c << std::endl;
    auto d = *c;
    std::cout << "copy of c: " << d << std::endl;
    auto e = std::move(*c);
    delete c;
    std::cout << "moved c: " << e << std::endl;
}