Memory and RAII

Lifetime categories

• Automatic storage: local variables
• Static storage: globals and static locals
• Dynamic storage: objects created with new or factory helpers

Prefer RAII

Resource Acquisition Is Initialization means the object owns the resource and releases it in the destructor.

class FileHandle {
public:
    explicit FileHandle(std::FILE* file) : file_{file} {}
    ~FileHandle() {
        if (file_) std::fclose(file_);
    }

private:
    std::FILE* file_{};
};

Smart pointers

auto p = std::make_unique<int>(42);
auto s = std::make_shared<std::string>("hello");
std::weak_ptr<std::string> weak = s;

• std::unique_ptr: single owner
• std::shared_ptr: shared ownership
• std::weak_ptr: non-owning observer for shared graphs

Move semantics

std::vector<std::string> names;
std::string temp = "Ada";
names.push_back(std::move(temp));

Move when ownership or expensive state should transfer, not just because std::move exists.

Best-practice reminders

• Avoid raw new and delete in application code.
• Prefer stack allocation when ownership is simple.
• Use std::unique_ptr by default.
• Use std::move only when you are done with the source object.

Custom deleters

using FilePtr = std::unique_ptr<std::FILE, int(*)(std::FILE*)>;
FilePtr file(std::fopen("data.txt", "r"), &std::fclose);

Custom deleters let smart pointers manage non-memory resources such as file handles, sockets, or OS descriptors.

Shared ownership warning

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;
};

If both directions used std::shared_ptr, the nodes could keep each other alive forever. Use std::weak_ptr to break cycles.

Views are not owners

• std::span, std::string_view, raw pointers, and references do not extend lifetime.
• Document who owns the data and how long borrowed views remain valid.

Exception-safety checklist

• Acquire resources into owning objects immediately.
• Prefer constructors and destructors to manual open() / close() pairs.
• Design moves as noexcept when possible to keep containers efficient.

Quick ownership guide

• simple local owner: stack object
• one heap owner: std::unique_ptr
• multiple real owners: std::shared_ptr
• non-owning borrowed access: reference, pointer, std::span, or std::string_view