Memory is the foundation of C++. Ownership is the architecture of C++. RAII is the philosophy of C++.

If you understand these three ideas deeply, you understand modern C++.

This chapter teaches you how modern C++ manages memory safely, predictably, and efficiently — without relying on manual new/delete, without leaking resources, and without creating fragile architectures. These concepts will shape every system you build later in the book.

In modern C++, ownership determines architecture.

Ownership answers:

• Who is responsible for this object?
• Who destroys it?
• Who can access it?
• Who may modify it?
• Who may share it?
• Who must not outlive it?

When ownership is unclear, systems become fragile. When ownership is explicit, systems become robust.

Modern C++ gives you tools to express ownership clearly.

Raw pointers (T*) do not express ownership.

A raw pointer means:

• “I point to something.”
• “I do not own it.”
• “I do not destroy it.”
• “I may be null.”
• “I may be dangling if misused.”

Raw pointers are non owning references, nothing more.

Use them when:

• You do not own the object
• You do not manage its lifetime
• You want optional access (nullptr)
• You want lightweight references

Example:

void AttachChild(Node* child); // does not own child

This is clear and intentional.

References (T&) are:

• Non owning
• Non null
• Must refer to a valid object
• Cannot be reseated

Use them when:

• The object must exist
• The function must not accept null
• You want clarity and safety

Example:

void Normalize(Vec3& v); // v must exist

References express strong intent.

Modern C++ uses smart pointers to express ownership explicitly:

std::unique_ptr<T> — Exclusive Ownership

• One owner
• Moves ownership
• Automatically destroys object
• Zero overhead compared to raw pointer

Example:

std::unique_ptr<Texture> texture = std::make_unique<Texture>("wood.png");

This is the modern replacement for new.

std::shared_ptr<T> — Shared Ownership

• Multiple owners
• Reference counting
• Automatically destroyed when last owner disappears
• Slight overhead due to atomic refcount

Example:

std::shared_ptr<Model> model = std::make_shared<Model>("tree.obj");

Use shared ownership sparingly — only when truly needed.

std::weak_ptr<T> — Non Owning Reference to Shared Object

• Does not contribute to refcount
• Prevents cycles
• Must be locked before use

Example:

std::weak_ptr<Node> parent;

Weak pointers express “I refer to this, but I do not keep it alive.”

RAII (Resource Acquisition Is Initialization) means:

• Acquire resources in constructors
• Release resources in destructors
• Lifetime is deterministic
• Cleanup is automatic

RAII applies to:

• Memory
• Files
• Network sockets
• Mutexes
• OpenGL objects
• Engine resources
• Any external handle

Example:

class File {
public:
    File(const std::string& path)
        : handle(std::fopen(path.c_str(), "rb"))
    {}

    ~File()
    {
        if (handle)
            std::fclose(handle);
    }

private:
    std::FILE* handle;
};

This is modern C++ at its best: safe, simple, predictable.

Modern C++ avoids manual memory management.

Instead of:

Texture* tex = new Texture("wood.png");
delete tex;

Use:

auto tex = std::make_unique<Texture>("wood.png");

Or, if shared:

auto tex = std::make_shared<Texture>("wood.png");

Manual memory management is error prone and unnecessary.

Move semantics allow ownership to transfer cheaply.

Example:

std::unique_ptr<Texture> a = std::make_unique<Texture>("wood.png");
std::unique_ptr<Texture> b = std::move(a);

After the move:

• b owns the texture
• a is empty
• No copy occurred
• No allocation occurred

Move semantics make modern C++ efficient and expressive.

Copy semantics apply to value types:

Vec3 a{1,2,3};
Vec3 b = a; // cheap copy

Copying is safe and predictable when:

• The type is small
• The type is POD
• The type has no external resources

Avoid copying types that manage resources.

Modern C++ uses consistent ownership patterns:

std::unique_ptr<Texture> texture;

std::shared_ptr<Node> root;

std::weak_ptr<Node> parent;

Node* currentTarget; // does not own

void Update(Transform& t);

These patterns make systems predictable and maintainable.

Common ownership mistakes to avoid include:

• Using raw pointers for ownership
• Using shared_ptr everywhere
• Using weak_ptr without understanding lifetime
• Returning raw pointers from owning functions
• Storing owning pointers in structs
• Using new/delete manually
• Forgetting to move unique_ptr

Modern C++ avoids these pitfalls through clear ownership rules.

In this chapter, you learned:

• Why ownership is the backbone of architecture
• Why raw pointers are non owning
• Why references are non null and non owning
• How smart pointers express ownership
• How RAII ensures deterministic cleanup
• Why manual memory management is obsolete
• How move semantics transfer ownership efficiently
• How to design ownership patterns for real systems
• How to avoid common ownership mistakes

These principles prepare you for the engineering chapters that follow.