Lambdas / Move / RAII

Move constructor & move assignment

• Move ctor: T(T&& other) noexcept — steal from other, null it out.
• Move assign: T& operator=(T&& other) noexcept — release old resource, then steal.
• Mark moves noexcept when safe so containers (e.g. vector) can relocate efficiently.
• **Rule of Zero:** prefer members that already manage memory (string, vector, unique_ptr).
• **Rule of Five:** if you define one of dtor/copy/move, review all five special members.

#include <utility>

class Buffer {
    char* data = nullptr;
    size_t n = 0;
public:
    explicit Buffer(size_t sz) : data(new char[sz]), n(sz) {}
    ~Buffer() { delete[] data; }

    Buffer(Buffer&& o) noexcept : data(o.data), n(o.n) {
        o.data = nullptr;
        o.n = 0;
    }
    Buffer& operator=(Buffer&& o) noexcept {
        if (this != &o) {
            delete[] data;
            data = o.data;
            n = o.n;
            o.data = nullptr;
            o.n = 0;
        }
        return *this;
    }
    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;
};

RAII with smart pointers

• unique_ptr — exclusive ownership; movable, not copyable.
• shared_ptr — shared ownership with reference counting.
• make_unique / make_shared are the preferred creators.
• Moving a unique_ptr transfers ownership — classic RAII + move combo.

#include <iostream>
#include <memory>
#include <utility>
using namespace std;

int main() {
    auto a = make_unique<int>(42);
    unique_ptr<int> b = std::move(a);
    cout << *b << "\n";
    cout << (a == nullptr) << "\n"; // 1
    return 0;
}

When copy runs vs when move runs

• Named objects prefer **copy** unless cast with std::move (or they are temporaries).
• Returning a local by value may use move or NRVO/copy elision.
• Deleted copy + available move ⇒ movable-only types (unique_ptr, streams).

RAII + exceptions

• Stack unwinding destroys locals — RAII still releases resources.
• Raw new without an owner can leak if something throws before delete.
• Never throw from a destructor during unwinding (can call terminate).

#include <memory>
using namespace std;

void work() {
    auto p = make_unique<int[]>(1000); // freed even if later code throws
    // ...
}

Design tips

• Keep lambdas short; extract a named function when the body grows.
• Do not std::move something you still need.
• Exclusive resources: delete copy, implement/allow move, or use unique_ptr.
• API surface: accept callables as templates; store them as std::function only when needed.