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.

Practice

1. What happens if you try to dereference a pointer that has not been initialized in C++?
int *p;
int x = *p;

easy

A. It causes undefined behavior and may crash the program.

B. It automatically initializes the pointer to zero.

C. It assigns zero to the variable x.

D. It prints the address stored in p.

Solution

1. Step 1: Understand pointer initialization

   The pointer p is declared but not initialized, so it points to an unknown memory location.

2. Step 2: Dereferencing uninitialized pointer

   Dereferencing *p tries to access memory at an undefined address, causing undefined behavior or crash.

3. Final Answer:

   It causes undefined behavior and may crash the program. -> Option A

4. Quick Check:

   Uninitialized pointer dereference = crash [OK]

Hint: Never use pointers before initializing them [OK]

Common Mistakes:

• Assuming uninitialized pointers are null
• Thinking dereferencing gives zero
• Ignoring pointer initialization

2. Which of the following is the correct way to initialize a pointer to null in C++?

easy

A. int *p = NULL;

B. int *p = nullptr;

C. int *p = '0';

D. int *p = 0x0;

Solution

1. Step 1: Understand null pointer initialization

   In modern C++, nullptr is the preferred way to initialize a pointer to null.

2. Step 2: Check other options

   NULL is old style (macro), 0x0 is a literal but less clear, and '0' is a char, not a pointer.

3. Final Answer:

   int *p = nullptr; -> Option B

4. Quick Check:

   Use nullptr for null pointers [OK]

Hint: Use nullptr for null pointers in modern C++ [OK]

Common Mistakes:

• Using character '0' instead of nullptr
• Using integer 0 instead of nullptr
• Confusing NULL macro with nullptr

3. What is the output of the following code?

int x = 10;
int *p = &x;
*p = 20;
std::cout << x << std::endl;

medium

A. 10

B. Address of x

C. Compilation error

D. 20

Solution

1. Step 1: Understand pointer assignment

   Pointer p stores the address of x. So *p refers to x.

2. Step 2: Modify value through pointer

   Assigning *p = 20; changes the value of x to 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Pointer dereference changes original variable [OK]

Hint: Changing *p changes the original variable [OK]

Common Mistakes:

• Confusing pointer value with pointed value
• Expecting original variable unchanged
• Thinking *p prints address

4. Identify the error in the following code snippet:

int *p = nullptr;
std::cout << *p << std::endl;

medium

A. Missing semicolon after nullptr.

B. Pointer p is not declared.

C. Dereferencing a null pointer causes runtime error.

D. std::cout cannot print pointer values.

Solution

1. Step 1: Analyze pointer initialization

   Pointer p is initialized to nullptr, meaning it points to nothing.

2. Step 2: Dereferencing null pointer

   Trying to access *p causes a runtime error (crash) because it points to no valid memory.

3. Final Answer:

   Dereferencing a null pointer causes runtime error. -> Option C

4. Quick Check:

   Dereference nullptr = crash [OK]

Hint: Never dereference nullptr or uninitialized pointers [OK]

Common Mistakes:

• Assuming nullptr can be dereferenced safely
• Ignoring runtime crash possibility
• Confusing pointer declaration with usage

5. Given the code below, what is the safest way to avoid a dangling pointer?

int *p = new int(5);
delete p;
// What should be done next?

hard

A. Set p to nullptr after delete.

B. Assign p to a new integer immediately.

C. Do nothing; pointer is automatically safe.

D. Use delete[] p; instead of delete p;.

Solution

1. Step 1: Understand delete effect

   After delete p;, the pointer p still holds the old address but memory is freed (dangling pointer).

2. Step 2: Prevent dangling pointer

   Setting p = nullptr; makes it clear pointer is invalid and safe to check before use.

3. Final Answer:

   Set p to nullptr after delete. -> Option A

4. Quick Check:

   Nullify pointer after delete to avoid dangling [OK]

Hint: Nullify pointers after delete to avoid dangling [OK]

Common Mistakes:

• Using delete[] for single object
• Not setting pointer to nullptr after delete
• Assuming pointer auto-clears after delete