Address and dereference operators in C++

Introduction

We use address and dereference operators to work with memory locations directly. This helps us access or change the value stored in a specific place in the computer's memory.

When you want to find the memory address of a variable.

When you want to access or change the value stored at a specific memory address.

When working with pointers to manage dynamic memory.

When passing large data to functions efficiently by using pointers.

When implementing data structures like linked lists or trees.

Syntax

C++

int* ptr = &variable;  // & is address operator
int value = *ptr;        // * is dereference operator

The & operator gives the memory address of a variable.

The * operator accesses the value stored at the memory address a pointer holds.

Examples

Here, p points to x. Using *p gets the value of x.

C++

int x = 10;
int* p = &x;  // p stores address of x
int y = *p;   // y gets value 10 from address stored in p

Dereferencing ptr lets us change a through the pointer.

C++

int a = 5;
int* ptr = &a;
*ptr = 20;  // changes value of a to 20

Prints the memory address of num and its value using pointer.

C++

int num = 7;
int* pNum = #
std::cout << "Address: " << pNum << " Value: " << *pNum << std::endl;

Sample Program

This program shows how to get the address of a variable, access its value through a pointer, and change the value using the dereference operator.

C++

#include <iostream>

int main() {
    int value = 42;
    int* pointer = &value;  // store address of value

    std::cout << "Value: " << value << "\n";
    std::cout << "Address of value: " << pointer << "\n";
    std::cout << "Value via pointer: " << *pointer << "\n";

    *pointer = 100;  // change value using pointer
    std::cout << "New value: " << value << "\n";

    return 0;
}

Important Notes

Memory addresses shown when running may look different each time.

Always initialize pointers before dereferencing to avoid errors.

Using * on a pointer accesses or changes the value at that memory location.

Summary

The & operator gets the address of a variable.

The * operator accesses or changes the value at the address a pointer holds.

Pointers let you work directly with memory, which is useful for efficient programming.

Practice

1. What does the & operator do in C++?

easy

A. It dereferences a pointer to get the value.

B. It multiplies two numbers.

C. It declares a pointer variable.

D. It gives the memory address of a 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, declare pointers, or dereference pointers; those are different operations.

3. Final Answer:

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

4. Quick Check:

   & operator = address retrieval [OK]

Hint: Remember & means 'address of' in C++ [OK]

Common Mistakes:

• Confusing & with multiplication operator
• Thinking & declares a pointer
• Mixing & with dereference * operator

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; declares a reference, not a pointer. int ptr*; and *int ptr; are invalid syntax.

3. Final Answer:

   int *ptr; -> Option A

4. Quick Check:

   Pointer declaration = int *ptr; [OK]

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

Common Mistakes:

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

3. What is the output of the following code?

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

medium

A. Address of x

B. 10

C. 20

D. Compilation error

Solution

1. Step 1: Understand pointer assignment

   Pointer p stores the address of x. Using *p = 20; changes the value at that address.

2. Step 2: Check the effect on x

   Since *p points to x, changing *p to 20 updates x to 20.

3. Final Answer:

   20 -> Option C

4. Quick Check:

   Dereferencing pointer changes original variable [OK]

Hint: Changing *p changes the value of x [OK]

Common Mistakes:

• Thinking *p is the address, not the value
• Expecting output to be original x (10)
• Confusing pointer variable with pointed value

4. Identify the error in this code snippet:

int x = 5;
int *p;
*p = x;
std::cout << *p << std::endl;

medium

A. Variable x is not declared.

B. Pointer p is not initialized before dereferencing.

C. Syntax error in pointer declaration.

D. Cannot assign value to *p.

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 initialize pointers before dereferencing [OK]

Hint: Initialize pointers before using *p [OK]

Common Mistakes:

• Dereferencing pointer without assigning address
• Assuming pointer auto-points to variable
• Confusing pointer declaration with initialization

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

int a = 3, b = 4;
int *p = &a;
int *q = &b;
int *temp = p;
p = q;
q = temp;
std::cout << *p << " " << *q << std::endl;

hard

A. 4 3

B. 3 4

C. 3 3

D. 4 4

Solution

1. Step 1: Understand pointer swapping

   Initially, p points to a (3), q points to b (4). The code swaps the pointers using temp.

2. Step 2: Check final pointer values

   After swapping, p points to b (4), and q points to a (3).

3. Final Answer:

   4 3 -> Option A

4. Quick Check:

   Pointer swap changes what they point to [OK]

Hint: Swapping pointers swaps the values they point to [OK]

Common Mistakes:

• Confusing swapping pointers with swapping values
• Expecting original order after swap
• Mixing pointer values and pointed values