Pointers and References in C++

# CHAPTER 11

Pointers and References #

1. Introduction #

2. Learning Objectives #

• Use the Address-of operator (&).

• Declare and use Pointers.

• Dereference pointers (*) to access data.

• Understand Null pointers.

• Use References as aliases.

• Implement Pass-by-Reference in functions.

3. The Address-of Operator (&) #

#include <iostream>
using namespace std;

int main() {
    int score = 100;
    cout << "Value: " << score << endl;
    cout << "Address: " << &score << endl; // Prints something like 0x7ffee123
    return 0;
}

4. What is a Pointer? #

Syntax: dataType* pointerName;

int score = 100;
int* ptr = &score; // ptr now holds the memory address of score

cout << ptr << endl; // Prints the address (e.g., 0x7ffee123)

Memory Visualization:

score variable:
+----------+
|   100    |
+----------+
 Address: 0x1000

ptr variable:
+----------+
|  0x1000  |  <--- Points to score!
+----------+
 Address: 0x2000

5. Dereferencing a Pointer (*) #

int score = 100;
int* ptr = &score;

cout << *ptr << endl; // Prints 100!

// You can also change the value THROUGH the pointer
*ptr = 200;
cout << score << endl; // Score is now 200!

6. Null Pointers (nullptr) #

int* p = nullptr; // Safe. 

7. References #

Syntax: dataType& refName = variable;

int apples = 5;
int& fruit = apples; // fruit is now an alias for apples

fruit = 10;
cout << apples; // Prints 10!

*Note: A reference is basically a pointer in disguise that is safer and easier to use because it doesn't require dereferencing (*).*

8. Mini Project: Swap Values #

#include <iostream>
using namespace std;

// Pass-by-Reference
void swapNumbers(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    cout << "Before: x=" << x << " y=" << y << endl;
    
    swapNumbers(x, y); // Passes the actual variables, not copies
    
    cout << "After: x=" << x << " y=" << y << endl;
    return 0;
}

9. Common Mistakes #

• Confusing * in declaration vs dereferencing: int* p means "declare a pointer". *p = 5 means "go to the address in p and set it to 5".

• Dereferencing nullptr or Garbage: int* p; *p = 5; -> Segmentation Fault Crash!

• Returning References to Local Variables:

// DISASTROUS BUG!
int& badFunction() {
    int local = 5;
    return local; // local is destroyed when function ends, returning a dangling reference!
}

10. Exercises #

1. 1. Declare a double variable. Create a pointer to it. Change the value of the double using the pointer, then print it.

1. 2. Rewrite the swapNumbers function using Pointers (int*) instead of References.

11. MCQ Quiz with Answers #

12. Interview Questions #

• Q: Explain the difference between a Pointer and a Reference.

• Q: What is Pass-by-Value vs. Pass-by-Reference?

• Q: What is a Segmentation Fault and what usually causes it?

13. Summary #

14. Next Chapter Recommendation #