Common pointer errors - Cheat Sheet & Quick Revision

Recall & Review

beginner

What happens if you dereference a NULL pointer in C?

Dereferencing a NULL pointer causes a runtime error called a segmentation fault, which usually crashes the program.

beginner

Why is using an uninitialized pointer dangerous?

An uninitialized pointer points to an unknown memory location, so dereferencing it can cause unpredictable behavior or crashes.

intermediate

What is a dangling pointer?

A dangling pointer points to memory that has already been freed or released, so using it can cause errors or corrupt data.

intermediate

What is the risk of pointer arithmetic errors?

Pointer arithmetic errors can cause pointers to point outside the intended memory area, leading to invalid memory access and program crashes.

intermediate

Why should you avoid freeing the same pointer twice?

Freeing the same pointer twice (double free) can corrupt the memory management system and cause crashes or security issues.

What does a NULL pointer represent in C?

A A pointer that points to no valid memory

B A pointer to the first element of an array

C A pointer to a freed memory block

D A pointer that points to a random memory location

A NULL pointer explicitly means it points to no valid memory location.

What is the main problem with using an uninitialized pointer?

A It always points to NULL

B It points to a random memory location

C It points to a valid variable

D It automatically allocates memory

Uninitialized pointers contain garbage values and can point anywhere, causing unsafe behavior.

What error can occur if you dereference a dangling pointer?

A Memory allocation success

B Compilation error

C Segmentation fault or undefined behavior

D No error, safe to use

Dangling pointers point to freed memory, so dereferencing them causes crashes or undefined behavior.

What is a double free error?

A Freeing the same memory twice

B Freeing two different pointers

C Not freeing allocated memory

D Freeing a NULL pointer

Double free means calling free() on the same pointer more than once, which corrupts memory management.

Pointer arithmetic can cause errors if:

A Pointer points to a local variable

B Pointer is set to NULL

C Pointer is initialized properly

D Pointer goes outside the allocated memory bounds

Moving pointers outside their allocated memory can cause invalid access and crashes.

Explain what a dangling pointer is and why it is dangerous.

Think about what happens after you free memory but still keep the pointer.

List common pointer errors in C and how to avoid them.

Consider initialization, freeing memory, and careful pointer use.

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