Module 8: Pointers in C++

A pointer is a variable that stores the memory address of another variable. Pointers are widely used for efficient memory management, dynamic memory allocation, arrays, functions, and advanced programming concepts.

Example:

cppCopy
1int age = 25;
2int* ptr = &age;
3
4cout << *ptr;

Output

textCopy
125

1. Introduction to Pointers

Pointers hold the memory address of variables instead of storing actual values.

Example

cppCopy
1#include <iostream>
2using namespace std;
3
4int main()
5{
6    int number = 100;
7    int* ptr = &number;
8
9    cout << ptr;
10
11    return 0;
12}

The output is the memory address of number.

2. Memory

Every variable is stored in the computer's memory at a unique address.

Example:

Pointers store these addresses rather than the values themselves.

3. Address Operator (&)

The address operator (&) returns the memory address of a variable.

Example

cppCopy
1int age = 20;
2
3cout << &age;

4. Dereference Operator (*)

The dereference operator (*) accesses the value stored at the pointer's address.

Example

cppCopy
1#include <iostream>
2using namespace std;
3
4int main()
5{
6    int value = 50;
7    int* ptr = &value;
8
9    cout << *ptr;
10
11    return 0;
12}

Output

textCopy
150

5. Pointer Arithmetic

Pointers can move through consecutive memory locations.

Example

cppCopy
1#include <iostream>
2using namespace std;
3
4int main()
5{
6    int arr[] = {10, 20, 30};
7
8    int* ptr = arr;
9
10    cout << *ptr << endl;
11
12    ptr++;
13
14    cout << *ptr;
15
16    return 0;
17}

Output

textCopy
110
220

6. Null Pointer

A null pointer does not point to any valid memory location.

Example

cppCopy
1int* ptr = nullptr;

Always initialize unused pointers with nullptr.

7. Void Pointer

A void pointer can store the address of any data type but must be cast before dereferencing.

Example

cppCopy
1#include <iostream>
2using namespace std;
3
4int main()
5{
6    int value = 100;
7
8    void* ptr = &value;
9
10    cout << *(int*)ptr;
11
12    return 0;
13}

Output

textCopy
1100

8. Wild Pointer

A wild pointer is an uninitialized pointer. Accessing it causes undefined behavior.

Incorrect Example

cppCopy
1int* ptr;
2
3cout << *ptr;

Always initialize pointers before use.

9. Dangling Pointer

A dangling pointer points to memory that has already been freed or is no longer valid.

Example

cppCopy
1int* ptr = new int(10);
2
3delete ptr;
4
5ptr = nullptr;

Assigning nullptr after delete helps prevent accidental access.

10. Pointers and Arrays

The name of an array acts as a pointer to its first element.

Example

cppCopy
1#include <iostream>
2using namespace std;
3
4int main()
5{
6    int numbers[] = {5, 10, 15};
7
8    int* ptr = numbers;
9
10    cout << *(ptr + 1);
11
12    return 0;
13}

Output

textCopy
110

11. Pointers and Functions

Pointers can be passed to functions to modify original values.

Example

cppCopy
1#include <iostream>
2using namespace std;
3
4void increment(int* value)
5{
6    (*value)++;
7}
8
9int main()
10{
11    int number = 10;
12
13    increment(&number);
14
15    cout << number;
16
17    return 0;
18}

Output

textCopy
111

12. Double Pointer

A double pointer stores the address of another pointer.

Example

cppCopy
1#include <iostream>
2using namespace std;
3
4int main()
5{
6    int value = 20;
7
8    int* ptr = &value;
9
10    int** dptr = &ptr;
11
12    cout << **dptr;
13
14    return 0;
15}

Output

textCopy
120

13. Smart Pointer Introduction

Smart pointers automatically manage dynamically allocated memory and help prevent memory leaks.

Common smart pointers:

• std::unique_ptr
• std::shared_ptr
• std::weak_ptr

Example

cppCopy
1#include <iostream>
2#include <memory>
3
4using namespace std;
5
6int main()
7{
8    unique_ptr<int> ptr = make_unique<int>(100);
9
10    cout << *ptr;
11
12    return 0;
13}

Output

textCopy
1100

Smart pointers were introduced in C++11 and are recommended over raw pointers for dynamic memory management.

Comparison of Pointer Types

Best Practices

• Initialize pointers with nullptr.
• Avoid using uninitialized (wild) pointers.
• Set pointers to nullptr after delete.
• Prefer smart pointers over raw pointers for dynamic memory.
• Check pointers before dereferencing them.
• Avoid unnecessary pointer arithmetic.

Practice Problems

1. Create a pointer to an integer and print its value.
2. Swap two numbers using pointers.
3. Traverse an array using pointer arithmetic.
4. Pass a pointer to a function and modify a variable.
5. Demonstrate a double pointer.
6. Allocate and free memory using new and delete.
7. Create a simple example using std::unique_ptr.

Interview Questions

1. What is a pointer in C++?
2. What is the difference between & and *?
3. What is pointer arithmetic?
4. What is a null pointer?
5. What is a void pointer?
6. What is a wild pointer?
7. What is a dangling pointer?
8. How are pointers used with arrays?
9. What is a double pointer?
10. Why are smart pointers preferred over raw pointers?

Summary

In this module, you learned:

• What pointers are and how they store memory addresses.
• How to use the address (&) and dereference (*) operators.
• How pointer arithmetic works with arrays.
• The differences between null, void, wild, and dangling pointers.
• How pointers interact with arrays and functions.
• How double pointers work.
• Why smart pointers are recommended for safer memory management.

Next Module: Module 9: Object-Oriented Programming (OOP) — Classes, Objects, Constructors, Destructors, Encapsulation, Inheritance, Polymorphism, Abstraction, Virtual Functions, Friend Functions, and Operator Overloading.