Address and dereference operators - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the address operator (&) do in C?

The address operator (&) gives the memory address of a variable. It tells where the variable is stored in memory.

beginner

What is the purpose of the dereference operator (*) in C?

The dereference operator (*) accesses the value stored at a given memory address (pointer). It lets you read or change the value the pointer points to.

beginner

Explain the difference between a pointer and a normal variable.

A normal variable stores a value directly. A pointer stores the address of another variable, not the value itself.

beginner

Given int x = 10; int *p = &x;, what does *p represent?

*p represents the value stored at the address held by p. Here, it is the value of x, which is 10.

intermediate

Why is it important to use the dereference operator carefully?

Using the dereference operator on an invalid or uninitialized pointer can cause errors or crashes because it tries to access memory that may not belong to your program.

What does the & operator do in C?

A Returns the address of a variable

B Dereferences a pointer

C Declares a pointer variable

D Assigns a value to a variable

The & operator returns the memory address of a variable.

If int *p = &x;, what does *p mean?

A The address of x

B A new pointer

C The value of x

D The size of x

*p accesses the value stored at the address pointed to by p, which is the value of x.

Which operator is used to get the value stored at a pointer's address?

A &

B *

C ->

D %

The * operator dereferences a pointer to get the value at the address.

What happens if you dereference a pointer that is not initialized?

A The program may crash or behave unpredictably

B You get the value zero

C It automatically initializes the pointer

D Nothing happens

Dereferencing an uninitialized pointer can cause crashes or undefined behavior.

Which of the following is a correct way to declare a pointer to an int?

A pointer int p;

B int p;

C int &p;

D int *p;

int *p; declares a pointer to an int.

Describe how the address (&) and dereference (*) operators work together with pointers in C.

Think about how you find where something is and then how you look inside it.

Explain why using the dereference operator on an invalid pointer is dangerous.

Consider what happens if you try to open a door that doesn't exist.

Practice

1. What does the & operator do in C?

easy

A. It gives the memory address of a variable.

B. It multiplies two numbers.

C. It dereferences a pointer to get the value.

D. It declares a pointer variable.

Solution

1. Step 1: Understand the & operator

   The & operator is used to get the address of a variable in memory.

2. Step 2: Differentiate from other operators

   It does not multiply, dereference, or declare pointers; those are different operations.

3. Final Answer:

   It gives the memory address of a variable. -> Option A

4. Quick Check:

   & means address-of [OK]

Hint: Remember & means 'address of' variable [OK]

Common Mistakes:

• Confusing & with multiplication operator
• Thinking & dereferences a pointer
• Mixing & with pointer declaration

2. Which of the following is the correct way to declare a pointer to an integer in C?

easy

A. *int ptr;

B. int &ptr;

C. int ptr*;

D. int *ptr;

Solution

1. Step 1: Recall pointer declaration syntax

   In C, a pointer to an int is declared as int *ptr; where * indicates pointer type.

2. Step 2: Check other options for syntax errors

   int &ptr; is invalid in C (it's C++ reference), int ptr*; and *int ptr; are incorrect syntax.

3. Final Answer:

   int *ptr; -> Option D

4. Quick Check:

   Pointer declaration uses * before variable name [OK]

Hint: Pointer declaration: type *name; [OK]

Common Mistakes:

• Using & instead of * for pointers
• Placing * after variable name incorrectly
• Confusing C++ references with pointers

3. What is the output of this code?

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

medium

A. 10

B. The memory address of x

C. Garbage value

D. Compilation error

Solution

1. Step 1: Understand pointer assignment

   Pointer p stores the address of x using &x.

2. Step 2: Dereference pointer to get value

   *p accesses the value at the address stored in p, which is 10.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   *p gives value at address [OK]

Hint: *p gives value stored at pointer address [OK]

Common Mistakes:

• Printing pointer variable instead of dereferenced value
• Confusing & and * operators
• Expecting address instead of value

4. Identify the error in this code snippet:

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

medium

A. Incorrect use of & operator.

B. Pointer p is not initialized before dereferencing.

C. Variable x is not declared.

D. Missing semicolon after declaration.

Solution

1. Step 1: Check pointer initialization

   Pointer p is declared but not assigned an address before *p = x;.

2. Step 2: Understand dereferencing uninitialized pointer

   Dereferencing p without initialization causes undefined behavior or crash.

3. Final Answer:

   Pointer p is not initialized before dereferencing. -> Option B

4. Quick Check:

   Always assign pointer before dereferencing [OK]

Hint: Initialize pointer before using * to access value [OK]

Common Mistakes:

• Dereferencing uninitialized pointer
• Confusing assignment with address-of
• Ignoring pointer initialization warnings

5. Given the code below, what will be the output?

int a = 3, b = 7;
int *p = &a;
*p = *p + 4;
p = &b;
*p = *p - 2;
printf("%d %d", a, b);

hard

A. 7 3

B. 3 5

C. 7 5

D. 7 7

Solution

1. Step 1: Modify value pointed by p initially

   p points to a. *p = *p + 4; changes a from 3 to 7.

2. Step 2: Change pointer to point to b and modify

   p = &b; points to b. *p = *p - 2; changes b from 7 to 5.

3. Step 3: Print final values

   a is 7 and b is 5.

4. Final Answer:

   7 5 -> Option C

5. Quick Check:

   Pointer changes values via dereference [OK]

Hint: Track pointer target and value changes stepwise [OK]

Common Mistakes:

• Not updating the correct variable via pointer
• Confusing pointer assignment with value assignment
• Ignoring pointer reassignment effects