C++ for C Developers | Lesson 12: Move Semantics & Rvalue References

// Simplified dynamic array
class Buffer {
private:
    char* m_data = nullptr;
    size_t m_size = 0;
public:
    Buffer(size_t size) : m_size(size) {
        m_data = new char[m_size];
        std::cout << "Buffer allocating " << m_size << " bytes\n";
    }
    ~Buffer() {
        std::cout << "Buffer deleting " << m_size << " bytes\n";
        delete[] m_data;
    }

    // Copy Constructor (Potentially Expensive!)
    Buffer(const Buffer& other) : m_size(other.m_size) {
        std::cout << "Buffer COPYING " << m_size << " bytes\n";
        m_data = new char[m_size]; // 1. Allocate new memory
        std::copy(other.m_data, other.m_data + m_size, m_data); // 2. Copy data element by element
    }

    // Copy Assignment Operator (Potentially Expensive!)
    Buffer& operator=(const Buffer& other) {
        std::cout << "Buffer COPY-ASSIGNING " << m_size << " bytes\n";
        if (this == &other) return *this; // Self-assignment check

        delete[] m_data; // 1. Delete old data
        m_size = other.m_size;
        m_data = new char[m_size]; // 2. Allocate new memory
        std::copy(other.m_data, other.m_data + m_size, m_data); // 3. Copy data
        return *this;
    }
    // ... other methods ...
};

Buffer createBuffer(size_t size) {
    return Buffer(size); // Returns a temporary Buffer object
}

int main() {
    Buffer b1(1000);
    Buffer b2 = b1; // Calls Copy Constructor (makes sense, we want two copies)

    Buffer b3(500);
    b3 = b1;       // Calls Copy Assignment Operator (makes sense)

    std::cout << "\n--- Creating from temporary ---\n";
    Buffer b4 = createBuffer(2000); // Creates temporary, then potentially COPIES it into b4
    std::cout << "---------------------------\n";

    // In pre-C++11, the copy from the temporary returned by createBuffer could be very costly.
    return 0;
}

#include <iostream>
#include <algorithm> // For std::copy
#include <utility>   // For std::move and std::swap

class Buffer {
private:
    char* m_data = nullptr;
    size_t m_size = 0;
public:
    // Constructor
    Buffer(size_t size) : m_size(size) {
        if (size > 0) m_data = new char[m_size];
        std::cout << "Buffer allocating " << m_size << " bytes at " << (void*)m_data << "\n";
    }
    // Destructor
    ~Buffer() {
        std::cout << "Buffer deleting " << m_size << " bytes at " << (void*)m_data << "\n";
        delete[] m_data;
    }

    // --- Copy Semantics ---
    // Copy Constructor
    Buffer(const Buffer& other) : m_size(other.m_size) {
        std::cout << "Buffer COPYING " << m_size << " bytes from " << (void*)other.m_data << "\n";
        if (m_size > 0) {
           m_data = new char[m_size];
           std::copy(other.m_data, other.m_data + m_size, m_data);
        } else {
            m_data = nullptr;
        }
    }
    // Copy Assignment
    Buffer& operator=(const Buffer& other) {
        std::cout << "Buffer COPY-ASSIGNING " << m_size << " bytes from " << (void*)other.m_data << "\n";
        if (this == &other) return *this;
        delete[] m_data; // Release old resource
        m_size = other.m_size;
        if (m_size > 0) {
            m_data = new char[m_size];
            std::copy(other.m_data, other.m_data + m_size, m_data);
        } else {
            m_data = nullptr;
        }
        return *this;
    }

    // --- Move Semantics (C++11) ---
    // Move Constructor
    Buffer(Buffer&& other) noexcept // Takes Rvalue Reference &&, marked noexcept
        : m_data(other.m_data), m_size(other.m_size) // 1. Steal the pointers/data
    {
        std::cout << "Buffer MOVING (constructor) " << m_size << " bytes from " << (void*)other.m_data << "\n";
        // 2. Leave the source object in a valid, destructible (empty) state
        other.m_data = nullptr;
        other.m_size = 0;
    }

    // Move Assignment Operator
    Buffer& operator=(Buffer&& other) noexcept // Takes Rvalue Reference &&, marked noexcept
    {
        std::cout << "Buffer MOVING (assignment) " << m_size << " bytes from " << (void*)other.m_data << "\n";
        if (this == &other) return *this; // Optional: Self-move check

        delete[] m_data; // 1. Release OWN resource

        // 2. Steal resources from other
        m_data = other.m_data;
        m_size = other.m_size;

        // 3. Leave other in a valid state
        other.m_data = nullptr;
        other.m_size = 0;

        return *this;
    }
     size_t size() const { return m_size; }
};

Buffer createBuffer(size_t size) {
    std::cout << "--- createBuffer called ---\n";
    Buffer local_buf(size);
    std::cout << "--- returning from createBuffer ---\n";
    return local_buf; // Returns Buffer (implicitly treated as Rvalue)
}

int main() {
    std::cout << "*** Scenario 1: Initialize from temporary ***\n";
    Buffer b1 = createBuffer(1000); // Calls Constructor, then MOVE Constructor! (Efficient)
    std::cout << "b1 size: " << b1.size() << "\n";
    std::cout << "*** End Scenario 1 ***\n\n";

    std::cout << "*** Scenario 2: Assign from temporary ***\n";
    Buffer b2(100); // Regular constructor
    b2 = createBuffer(2000); // Calls Constructor, then MOVE Assignment! (Efficient)
    std::cout << "b2 size: " << b2.size() << "\n";
    std::cout << "*** End Scenario 2 ***\n\n";

    std::cout << "*** Scenario 3: Explicit Move ***\n";
    Buffer b3(500);
    std::cout << "Before move, b3 size: " << b3.size() << "\n";
    // Buffer b4 = b3; // This would COPY
    Buffer b4 = std::move(b3); // Calls MOVE constructor explicitly
    std::cout << "After move, b3 size: " << b3.size() << "\n"; // b3 is now empty!
    std::cout << "After move, b4 size: " << b4.size() << "\n";
    std::cout << "*** End Scenario 3 ***\n\n";

    return 0; // Destructors called for b1, b2, b3 (empty), b4
}