C++ Academy · Pelajaran

std::move dan std::forward

Ubah lvalue menjadi rvalue dengan std::move dan pertahankan kategori nilai dengan std::forward

std::move dan std::forward adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C++ Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C++ Academy mencakup 4 pelajaran total.

Dua Kerabat, Tugas Berbeda

std::move dan std::forward sama-sama merupakan konversi tipe saat kompilasi. Keduanya terlihat serupa, tetapi menyelesaikan masalah yang berbeda.

std::move: Selalu Mengonversi ke Rvalue

std::move(x) tanpa syarat mengonversi x menjadi referensi rvalue. Fungsi penerima kemudian dapat mengambil alih sumber dayanya.

std::string s = "Hello";
std::string t = std::move(s);   // move-constructs t from s
// s is now in a valid-but-unspecified state

Kapan Menggunakan move

Gunakan std::move dalam:

Konstruktor pemindahan dan operator penugasan pemindahan
Mengembalikan variabel lokal saat Anda ingin memaksa pemindahan (jarang diperlukan — RVO biasanya berlaku)
Meneruskan variabel lokal yang tidak lagi Anda perlukan ke fungsi penampung

Implementasi std::move

Fungsi ini hanyalah static_cast yang disamarkan:

template <typename T>
typename std::remove_reference<T>::type&& move(T&& t) noexcept {
    return static_cast<typename std::remove_reference<T>::type&&>(t);
}

std::forward: Mempertahankan Kategori

Dalam templat yang menggunakan referensi penerusan (T&&), std::forward<T>(x) mengonversi x kembali ke kategori aslinya (lvalue atau rvalue). Digunakan untuk penerusan sempurna.

template <typename T>
void wrapper(T&& arg) {
    target(std::forward<T>(arg));  // forwards as lvalue or rvalue depending on T
}

Mengapa Penerusan Diperlukan

Di dalam templat, parameter memiliki nama — sehingga menjadi lvalue, meskipun pemanggil meneruskan rvalue. std::forward mengembalikan kategori aslinya.

Tanpa std::forward

Tanpa forward, setiap argumen akan diteruskan sebagai lvalue di dalam wrapper, sehingga semantik pemindahan yang diinginkan pemanggil tidak dapat digunakan.

template <typename T>
void wrapper(T&& arg) {
    target(arg);    // always lvalue — wrong
}

Selalu Tentukan Parameter Templat untuk forward

std::forward<T> memerlukan argumen templat yang ditentukan secara eksplisit. Tanpanya, perilakunya akan keliru.

Contoh Penerusan Sempurna

Fungsi pabrik yang meneruskan argumen konstruktor mempertahankan perbedaan rvalue/lvalue demi efisiensi.

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Pindahkan Sekali

Setiap objek sebaiknya dipindahkan paling banyak satu kali. Setelah dipindahkan, objek berada dalam keadaan valid tetapi tidak ditentukan — biasanya Anda menetapkan nilai baru atau menghancurkannya. Menggunakan objek yang sudah dipindahkan tanpa menetapkan nilai baru terlebih dahulu berisiko menimbulkan kesalahan yang sulit dideteksi.

Aturan Praktis

Model mental singkat:

Memiliki tipe konkret dan ingin memindahkannya → std::move
Memiliki parameter templat dan ingin mempertahankan kategorinya → std::forward<T>

Pemeriksaan Singkat

Di dalam fungsi templat dengan parameter T&& arg, bagaimana Anda meneruskan arg sambil mempertahankan kategorinya sebagai lvalue/rvalue?

Ringkasan

std::move tanpa syarat mengonversi ke rvalue — gunakan pada objek konkret yang sumber dayanya ingin Anda ambil alih. std::forward<T> mempertahankan kategori nilai di dalam templat generik — gunakan untuk penerusan sempurna.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “std::move dan std::forward” gratis?

Ya — teks lengkap “std::move dan std::forward” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C++ Academy, upgrade ke CoddyKit PRO. Kursus C++ Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “std::move dan std::forward”?

Ubah lvalue menjadi rvalue dengan std::move dan pertahankan kategori nilai dengan std::forward Kamu berlatih C++ Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C++ Academy?

Tidak diperlukan pengalaman sebelumnya. C++ Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “std::move dan std::forward” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy