Move constructor and move assignment — Rule of Five

5.2.10 · Coding › C++ Programming

Move exist hi kyun karta hai?

KYA optimize ho raha hai: O(N) heap buffer copy ko O(1) pointer copy se replace kiya ja raha hai.

KAISE compiler ko pata chalta hai ki safe hai: source ek rvalue hai (ek temporary ya kuch jo tum explicitly std::move se cast karte ho). Rvalues ka koi naam nahi hota jise tum dobara use kar sako, isliye unse churana safe hai.

Paanch special members

Move constructor ko scratch se derive karna

Chalo ek minimal Buffer banate hain jo ek heap array own karta hai.

class Buffer {
    int*   data_;
    size_t size_;
public:
    // 0. Constructor
    Buffer(size_t n) : data_(new int[n]{}), size_(n) {}
 
    // 1. Destructor
    ~Buffer() { delete[] data_; }
 
    // 2. Copy constructor — DEEP copy
    Buffer(const Buffer& o) : data_(new int[o.size_]), size_(o.size_) {
        std::copy(o.data_, o.data_ + o.size_, data_);   // Why? source must survive intact
    }
 
    // 3. Copy assignment — copy-and-swap idiom
    Buffer& operator=(const Buffer& o) {
        Buffer tmp(o);        // Why? reuse copy ctor; strong exception safety
        swap(*this, tmp);     // Why? swap is noexcept; tmp's dtor frees our old data
        return *this;
    }
 
    // 4. Move constructor — STEAL
    Buffer(Buffer&& o) noexcept
        : data_(o.data_), size_(o.size_) {  // Why? grab the pointer, no allocation
        o.data_ = nullptr;                  // Why? so o's dtor won't free what we now own
        o.size_ = 0;
    }
 
    // 5. Move assignment — STEAL into existing
    Buffer& operator=(Buffer&& o) noexcept {
        if (this != &o) {            // Why? guard against self-move
            delete[] data_;          // Why? free our current resource first
            data_  = o.data_;        // steal
            size_  = o.size_;
            o.data_ = nullptr;       // leave source in valid empty state
            o.size_ = 0;
        }
        return *this;
    }
 
    friend void swap(Buffer& a, Buffer& b) noexcept {
        std::swap(a.data_, b.data_);
        std::swap(a.size_, b.size_);
    }
};

Figure — Move constructor and move assignment — Rule of Five

Worked examples

Worked example Example 1 — ek temporary se move construction

Buffer make() { return Buffer(1000); }
Buffer b = make();   // move ctor (or elided entirely)

Yeh step kyun? make() ek prvalue return karta hai. Modern compilers aksar elide kar dete hain move ko (copy elision / RVO), lekin jab elide nahi hota tab bhi move ctor chalta hai — copy ctor kabhi nahi. Koi 1000-int copy nahi hoti.

Worked example Example 2 — explicit

std::move

Buffer a(1000);
Buffer c = std::move(a);  // move ctor: a is now empty (size_ == 0)
// a.data_ == nullptr; using a's contents now is a logic bug

Yeh step kyun? a ek lvalue hai (uska naam hai). std::move(a) sirf ek rvalue reference ka cast hai — yeh khud kuch move nahi karta; yeh sirf move ctor ko select hone ki ijazat deta hai. Move ke baad, a valid hai but unspecified — destroy ya reassign karna safe hai, meaningful tarike se read karna nahi.

Worked example Example 3 —

noexcept kyun matter karta hai

std::vector<Buffer> v;
v.push_back(Buffer(10));   // reallocation may move elements

Yeh step kyun? Jab vector grow karta hai, to existing elements ko naye storage mein move karta hai. Yeh tumhara move ctor tabhi use karega jab wo noexcept ho; warna strong exception guarantee preserve karne ke liye copy pe fall back karega. noexcept bhoolna silently tumhari move optimization ko containers mein khatam kar deta hai.

Flashcards

Move constructor kya steal karta hai aur peeche kya chodna chahiye?

Wo source se resource (jaise pointer) steal karta hai, aur source ko ek valid, destructible empty state mein chodna chahiye (jaise pointer ko nullptr set karo).

Rule of Five batao.

Agar tum destructor, copy ctor, ya copy assignment mein se koi bhi define karo, to paanch saare define karo: destructor, copy ctor, copy assignment, move ctor, move assignment.

std::move(x) runtime pe actually kya karta hai?

Kuch nahi — yeh x ka compile-time cast hai rvalue reference mein, jisse move ctor/assignment select ho sake. Actual stealing usi move operation ke andar hoti hai.

Move operations ko noexcept kyun mark karna chahiye?

Taaki standard containers (jaise reallocation pe std::vector) strong exception guarantee rakhne ke liye copy pe fall back karne ke bajay move use karein.

Agar tum destructor likhte ho lekin pointer member ke liye implicit copy constructor pe rely karte ho to kya bug aata hai?

Shallow pointer copy → do objects ek hi buffer own karte hain → double free / dangling pointer crash.

Move mein source ko null kyun karo?

Taaki source ka destructor wo resource free na kare jo destination ab own karta hai.

Copy aur move constructor ke signature mein kya difference hai?

Copy: T(const T&). Move: T(T&&) noexcept.

Move assignment mein self-assignment check kyun rakho?

Apna hi resource delete karne aur phir dangling pointer read karne se bachne ke liye jab x = std::move(x) hota hai (aksar generic algorithms ke through).

Recall Feynman: 12-saal ke bachche ko explain karo

Socho tum ghar shift kar rahe ho. Copying = bilkul same naya furniture khareedna, phir purana phenkna. Kitna waste! Moving = purana ghar waise bhi giraya ja raha hai, to bas apna existing furniture naye ghar le jaao aur purana khali chod do taaki crew tumhara sofa na tod de. "Rule of Five" woh paanch kaam ki checklist hai jo tumhe khatam karni hai taaki do families ek hi sofa na own karein (jo ek fight = ek crash ka kaaran banega).

Connections

Rule of Three — pre-C++11 ancestor (D, copy-ctor, copy-assign)
Rule of Zero — RAII members prefer karo taaki paanch mein se koi bhi na likhna pade
std::move and rvalue references — wo cast jo moves enable karta hai
Copy elision and RVO — jab move bhi skip ho jaata hai
Smart pointers (unique_ptr / shared_ptr) — move-only aur RAII resource owners
Exception safety guarantees — kyun noexcept aur copy-and-swap matter karta hai