<!--
Main idea: Pointers store addresses, not values

Key analogy: Sticky note with house address
- The note isn't the house
- It tells you where to find the house
- You can have multiple notes to the same address

[click] Show the diagram - reinforce the mental model
-->

<!--
[HOOK] Have you ever had your program crash with a mysterious "segmentation fault"?

You're not alone. Memory errors are one of the most frustrating bugs to track down.

Today, we're going to demystify what's happening under the hood...
-->

<!--
[HOOK] Quick question: What do you think happens when you write `int x = 5;`?

Most people say "it stores 5 in x" - and that's partially right.

But there's actually a lot more going on...
-->

<!--
[HOOK] There's a feature in modern C++ that eliminates an entire category of bugs.

And most codebases still aren't using it correctly.

Let's fix that today...
-->

<!--
SECTION: What is a Smart Pointer?

First, let's understand the problem it solves...

[click] Show the manual memory example

This is how we used to do it. Notice we have to remember to delete.

[click] Show what happens when we forget

Memory leak! The program keeps consuming memory until...

[PAUSE] Let this sink in

[click] Now show the smart pointer version

See how the cleanup happens automatically?

[TRANSITION] Now let's look at the different types...
-->

<!--
SUMMARY: Let's recap what we learned

[click] First takeaway - make sure they got this

This is the most important point. If you remember nothing else...

[click] Second takeaway - practical application

You'll use this pattern constantly in real code.

[click] Third takeaway - common mistake to avoid

I see this error in code reviews all the time.

[PAUSE] Give them a moment

[TRANSITION] Now for some practice...
-->

<!--
Introduce the concept of ownership...

[click] First bullet appears

Ownership means one thing is responsible for cleanup.

[click] Second bullet

Only the owner can delete the resource.

[click:2] Skip to the code example

Now let's see this in action...
-->

<!--
[SHOW CODE] Look at line 5

Notice how we're using make_unique here.

[VISUAL CUE] The diagram on the right shows memory layout

See how the pointer and the data are in different locations?

[HIGHLIGHT] This line is the key insight
-->

<!--
And this is the critical insight...

[PAUSE] Let that sink in

[SLOW] Memory. Is. Not. Automatic. In. C++.

[TRANSITION] Now that we understand the problem, let's look at the solution...
-->

<!--
[QUESTION] So what happens when this function returns?

Take a moment to think about it...

[THINK] Where does the memory go?

[EXAMPLE] Let me show you a real bug I found in production code...
-->

<!--
First, let me explain what we're trying to do.

We want to allocate memory that automatically cleans up.

[click] Show the code

Now look at this code. See how we use make_unique?

The key here is that we never call delete ourselves.
When ptr goes out of scope, cleanup happens automatically.
-->

<!--
Here's the old way - manual memory management.

[click] Show problematic code

See all these delete calls? Every single one is a potential bug.

Miss one? Memory leak.
Delete twice? Crash.
Exception thrown? Memory leak.

[PAUSE]

[click] Now the modern way

One line. Automatic cleanup. Exception safe.

This is why smart pointers exist.
-->

<!--
Let's start with the simplest case.

[click] Basic example

Just creating a single integer. Nothing fancy.

[click] Add a function call

Now we're passing it to a function. Still straightforward.

[click] Add exception handling

Here's where it gets interesting. What if process() throws?

[click] Show the problem

See the leak? The delete never runs!

[click] Show the solution

Smart pointer handles this automatically.
-->

<!--
This part trips up a lot of people, so don't worry if it doesn't click immediately.

Let me show you a different way to think about it...
-->

<!--
If you understood that, you've already grasped the hardest part.

The rest is just variations on this theme.
-->

<!--
Three rules for smart pointers:

One: Use unique_ptr by default.
Two: Use shared_ptr when you need shared ownership.
Three: Never use raw new.

That's it. Those three rules will prevent most memory bugs.
-->

<!--
Before we dive in, let me set some context.

We're assuming you know basic C++ syntax.
If terms like "stack" and "heap" are new, check out our memory basics video first.

Ready? Let's go.
-->

<!--
[QUESTION] Now here's where most people go wrong.

[click] Show the bad code

This looks reasonable, right? But there's a subtle bug.

[PAUSE]

Can you spot it?

[click] Highlight the problem

The issue is ownership. Who's responsible for deleting this?

[click] Show the fix

Here's how to fix it...
-->

<!--
[EXAMPLE] I see this pattern in production code all the time.

Just last week, I was reviewing code that looked exactly like this.

[click] Show the code

See the problem? They're storing raw pointers in a vector.

When the function returns, all those pointers are invalid.

This bug made it to production and caused intermittent crashes.

Smart pointers would have prevented it entirely.
-->

<!--
[THINK] Before I show you the answer, try to figure it out yourself.

What do you think happens when we call this function?

[PAUSE] Give them 3-4 seconds

[click] Reveal the answer

If you said "undefined behavior" - you're right!
-->