Common pointer errors - Step-by-Step Execution

Concept Flow - Common pointer errors

Declare pointer

↓

Initialize pointer

↓

Use pointer

↓

Check for errors?

No→Continue

Yes↓

Common errors: NULL, uninitialized, dangling, wrong type

↓

Fix errors: proper init, check NULL, correct type

↓

Safe pointer use

This flow shows how pointers are declared, initialized, used, and how common errors occur and are fixed.

Execution Sample

C

int *p;
int x = 10;
p = &x;
printf("%d", *p);

Declare a pointer p, assign it the address of x, then print the value pointed by p.

Execution Table

Step	Action	Pointer p	Variable x	Output	Error?
1	Declare pointer p	uninitialized	uninitialized		No
2	Declare int x=10	uninitialized	10		No
3	Assign p = &x	address of x	10		No
4	Print *p	address of x	10	10	No
5	End	address of x	10	10	No

💡 Program ends after printing value 10 pointed by p.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
p	uninitialized	uninitialized	address of x	address of x	address of x
x	uninitialized	10	10	10	10

Key Moments - 3 Insights

Why is it wrong to use a pointer before initializing it?

Using an uninitialized pointer (see Step 1 and 2 in execution_table) means it points to an unknown memory location, causing undefined behavior or crashes.

What happens if you dereference a NULL pointer?

Dereferencing a NULL pointer causes a runtime error (crash). Always check if pointer is NULL before dereferencing (not shown in this simple example).

Why must the pointer type match the variable type it points to?

Pointer type tells the compiler how many bytes to read. Mismatched types can cause wrong data access or crashes.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of pointer p after Step 3?

A uninitialized

B address of x

C NULL

D value 10

💡 Hint

Check the 'Pointer p' column at Step 3 in execution_table.

At which step does the program output the value 10?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Output' column in execution_table.

If pointer p was not assigned &x, what error would likely occur when printing *p?

A Undefined behavior or crash

B No error, prints 0

C Prints value of x anyway

D Compiler error

💡 Hint

Refer to key_moments about uninitialized pointer usage.

Concept Snapshot

Pointers hold memory addresses.
Always initialize pointers before use.
Dereferencing NULL or uninitialized pointers causes errors.
Pointer type must match variable type.
Check pointers before dereferencing to avoid crashes.

Full Transcript

This lesson shows common pointer errors in C. We declare a pointer p and an integer x. Initially, p is uninitialized, which is unsafe. We assign p the address of x, then print the value pointed by p, which is 10. Common errors include using pointers before initialization, dereferencing NULL pointers, and mismatched pointer types. Always initialize pointers properly and check for NULL before use to avoid crashes.

Practice

1. What is a common mistake when using pointers in C?

easy

A. Assigning a valid memory address to a pointer

B. Declaring pointers with the correct syntax

C. Using uninitialized pointers before assigning them an address

D. Using pointers to access array elements correctly

Solution

1. Step 1: Understand pointer initialization

   Pointers must be assigned a valid memory address before use to avoid undefined behavior.

2. Step 2: Identify common mistakes

   Using a pointer without initialization can cause crashes or unexpected results.

3. Final Answer:

   Using uninitialized pointers before assigning them an address -> Option C

4. Quick Check:

   Uninitialized pointer use = common error [OK]

Hint: Always initialize pointers before use to avoid errors [OK]

Common Mistakes:

• Dereferencing NULL pointers
• Forgetting to initialize pointers
• Confusing pointer and value assignment

2. Which of the following pointer declarations is syntactically correct in C?

easy

A. *int ptr;

B. int ptr*;

C. int &ptr;

D. int *ptr;

Solution

1. Step 1: Review pointer declaration syntax

   In C, the asterisk (*) goes between the type and the pointer name to declare a pointer.

2. Step 2: Check each option

   int *ptr; correctly declares a pointer to int. Options A, B, and D have invalid syntax.

3. Final Answer:

   int *ptr; -> Option D

4. Quick Check:

   Correct pointer syntax = int *ptr; [OK]

Hint: Pointer syntax: type *name; always asterisk before name [OK]

Common Mistakes:

• Placing * after variable name
• Using & instead of * for pointers
• Incorrect order of type and *

3. What will be the output of the following C code?

int x = 10;
int *p = &x;
*p = 20;
printf("%d", x);

medium

A. 10

B. 20

C. Garbage value

D. Compilation error

Solution

1. Step 1: Understand pointer assignment

   Pointer p points to variable x. Changing *p changes x's value.

2. Step 2: Trace the code execution

   *p = 20 sets x to 20. printf prints x, so output is 20.

3. Final Answer:

   20 -> Option B

4. Quick Check:

   Pointer dereference changes value = 20 [OK]

Hint: Changing *p changes the value pointed to [OK]

Common Mistakes:

• Confusing pointer address and value
• Expecting original value unchanged
• Ignoring pointer dereference effect

4. Identify the error in the following code snippet:

int *p;
*p = 5;
printf("%d", *p);

medium

A. Pointer p is not initialized before dereferencing

B. Syntax error in pointer declaration

C. Incorrect printf format specifier

D. No error, code runs fine

Solution

1. Step 1: Check pointer initialization

   Pointer p is declared but not assigned an address before use.

2. Step 2: Understand dereferencing consequences

   Dereferencing uninitialized pointer causes undefined behavior or crash.

3. Final Answer:

   Pointer p is not initialized before dereferencing -> Option A

4. Quick Check:

   Uninitialized pointer dereference = error [OK]

Hint: Always assign pointer before dereferencing [OK]

Common Mistakes:

• Assuming declaration initializes pointer
• Ignoring runtime crashes from bad pointers
• Misreading error as printf issue

5. Consider the code below. What is the safest way to avoid a common pointer error here?

int *p = NULL;
// Some code
printf("%d", *p);

hard

A. Check if p is NULL before dereferencing

B. Assign p to a random memory address

C. Remove the pointer and use an int variable instead

D. Ignore the NULL and dereference directly

Solution

1. Step 1: Understand NULL pointer risks

   Dereferencing NULL pointer causes runtime crash or undefined behavior.

2. Step 2: Apply safe pointer usage

   Always check if pointer is NULL before dereferencing to avoid errors.

3. Final Answer:

   Check if p is NULL before dereferencing -> Option A

4. Quick Check:

   NULL check before dereference = safe code [OK]

Hint: Always test pointer != NULL before use [OK]

Common Mistakes:

• Dereferencing NULL pointer causing crash
• Assigning invalid addresses
• Ignoring pointer safety checks