मूव सिमेंटिक्स और std::move

#include <iostream>
#include <cstring>
#include <utility>
#include <algorithm>

class Buffer {
    char* data_;
    std::size_t size_;
public:
    // Constructor
    explicit Buffer(std::size_t n) : data_(new char[n]()), size_(n) {
        std::cout << "Alloc " << n << " bytes\n";
    }

    // Destructor
    ~Buffer() {
        delete[] data_;
        std::cout << "Free (" << size_ << ")\n";
    }

    // Copy constructor (expensive — O(n))
    Buffer(const Buffer& other) : data_(new char[other.size_]), size_(other.size_) {
        std::memcpy(data_, other.data_, size_);
        std::cout << "Copy " << size_ << " bytes\n";
    }

    // Move constructor (cheap — O(1)) — MUST be noexcept
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;  // leave source in valid state
        other.size_ = 0;
        std::cout << "Move " << size_ << " bytes\n";
    }

    // Move assignment — MUST be noexcept
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;          // release own resources
            data_ = other.data_;     // steal source's resources
            size_ = other.size_;
            other.data_ = nullptr;   // leave source valid
            other.size_ = 0;
        }
        return *this;
    }

    // Copy assignment (omitted for brevity)
    std::size_t size() const { return size_; }
};

int main() {
    Buffer a(1'000'000);     // Alloc 1000000 bytes
    Buffer b = std::move(a); // Move 1000000 bytes — O(1)!
    std::cout << "a.size: " << a.size() << '\n';  // 0 (moved-from)
    std::cout << "b.size: " << b.size() << '\n';  // 1000000
}

#include <string>
#include <vector>
#include <iostream>

// GOOD: Rule of Zero — compiler generates everything
struct Employee {
    std::string name;
    std::vector<std::string> skills;
    int id;
    // No user-declared special members — compiler generates all 5
};

// BAD: Rule of Five violation — destructor suppresses moves
struct Resource {
    int* data;
    Resource() : data(new int(42)) {}
    ~Resource() { delete data; }  // move operations NOT generated!
    // This class will COPY where it could move
    // Fix: declare all five special members
};

int main() {
    Employee e1{"Alice", {"C++", "Rust"}, 1};
    Employee e2 = std::move(e1);  // compiler-generated move
    std::cout << e2.name << '\n';  // "Alice"

    static_assert(std::is_nothrow_move_constructible_v<Employee>,
                  "Employee should be nothrow-movable");
    // static_assert(std::is_nothrow_move_constructible_v<Resource>,
    //               "FAILS — Resource has no move constructor");
}