Common pointer mistakes in C++ - Step-by-Step Execution

Concept Flow - Common pointer mistakes

Declare pointer

↓

Initialize pointer?

No→Undefined behavior

Yes↓

Use pointer

↓

Dereference pointer

↓

Pointer valid?

No→Crash or garbage

↓

Access value

↓

Pointer arithmetic

↓

Pointer reassignment

↓

End or delete pointer

↓

Dangling pointer?

Yes→Use after free error

No↓

Program ends safely

This flow shows common pointer mistakes like uninitialized pointers, invalid dereference, and dangling pointers leading to crashes or unexpected behavior.

Execution Sample

C++

int* p;
*p = 10;
int x = 5;
p = &x;
int y = *p;

This code shows a pointer declared but not initialized, then used, causing undefined behavior.

Execution Table

Step	Code line	Pointer p	Action	Result/Output
1	int* p;	uninitialized	Declare pointer p	p points nowhere (garbage)
2	*p = 10;	uninitialized	Dereference p and assign 10	Undefined behavior (crash or memory corruption)
3	int x = 5;	uninitialized	Declare int x with value 5	x = 5
4	p = &x;	points to x	Assign address of x to p	p now points to x
5	int y = *p;	points to x	Dereference p to get value	y = 5

💡 Execution stops after line 5; line 2 causes undefined behavior due to uninitialized pointer dereference.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
p	undefined	uninitialized	uninitialized (used incorrectly)	uninitialized (used incorrectly)	address of x	address of x
x	undefined	undefined	undefined	5	5	5
y	undefined	undefined	undefined	undefined	undefined	5

Key Moments - 3 Insights

Why is dereferencing pointer p at step 2 a mistake?

At step 2, p is uninitialized and points to an unknown memory location, so dereferencing it causes undefined behavior (see execution_table row 2).

What changes after assigning p = &x at step 4?

After step 4, p points to the valid memory address of x, so dereferencing p is safe (see execution_table row 4).

Why does y get the value 5 at step 5?

Because p points to x which has value 5, dereferencing p gives 5, which is assigned to y (see execution_table row 5).

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What is the state of pointer p?

A p is uninitialized and used incorrectly

B p points to x

C p is null

D p points to y

💡 Hint

Check the 'Pointer p' column at step 2 in execution_table.

At which step does pointer p get assigned a valid address?

A Step 1

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the step where 'Pointer p' changes from uninitialized to pointing to x.

If we remove line 2 (*p = 10;), what would happen?

A Program crashes at step 4

B No undefined behavior, p safely points to x at step 4

C y gets garbage value

D p remains uninitialized

💡 Hint

Refer to execution_table and variable_tracker to see effect of skipping step 2.

Concept Snapshot

Common pointer mistakes in C++:
- Declaring pointer without initialization leads to undefined behavior when dereferenced.
- Always assign pointer to a valid address before use.
- Dereferencing uninitialized or null pointers causes crashes.
- Dangling pointers occur when memory is freed but pointer still used.
- Always ensure pointer points to valid memory before dereferencing.

Full Transcript

This lesson shows common pointer mistakes in C++. We declare a pointer p without initializing it. Then we try to assign a value through p, which causes undefined behavior because p points nowhere valid. Next, we declare an integer x and assign its address to p. Now p points to x safely. Finally, we read the value through p into y, which works correctly. The key mistakes are using pointers before initialization and dereferencing invalid pointers. Always initialize pointers before use to avoid crashes or unexpected results.