Pointers and References in C++

What are Pointers in C++?

A pointer is a variable that stores the memory address of another variable. Pointers allow you to access and manipulate the value of a variable directly through its memory address.

Why Use Pointers?

• Direct access to memory (low-level control).
• Dynamic memory allocation.
• Efficient function parameter passing (pass by reference).
• Implementing complex data structures (linked lists, trees, etc.).

Declaring Pointers

To declare a pointer, use the * (asterisk) symbol before the pointer name.

Syntax:

data_type *pointer_name;

Example:

#include <iostream>
using namespace std;

int main() {
    int number = 10;
    int *ptr = &number;  // Pointer storing the address of number

    cout << "Value of number: " << number << endl;
    cout << "Address of number: " << &number << endl;
    cout << "Pointer value (address): " << ptr << endl;
    cout << "Value at pointer: " << *ptr << endl;

    return 0;
}

Output:

Value of number: 10
Address of number: 0x61fe1c
Pointer value (address): 0x61fe1c
Value at pointer: 10

Explanation:

• &number gives the address of the variable number.
• ptr is a pointer that stores this address.
• *ptr dereferences the pointer, accessing the value at that memory address.

Pointer Basics

• A pointer can only store addresses of variables of the same type.
• The * operator is used to dereference a pointer (access the value at the address it points to).
• The & operator is used to get the address of a variable.

Example (Pointer Arithmetic):

#include <iostream>
using namespace std;

int main() {
    int arr[] = {10, 20, 30};
    int *ptr = arr;

    cout << "Pointer pointing to: " << *ptr << endl;  // 10
    ptr++;  // Move pointer to next element
    cout << "Pointer pointing to: " << *ptr << endl;  // 20

    return 0;
}

Output:

Pointer pointing to: 10
Pointer pointing to: 20

Types of Pointers

1. Null Pointers
2. Void Pointers (Generic Pointers)
3. Dangling Pointers
4. Constant Pointers and Pointers to Constants
5. Pointer to Pointer (Double Pointer)

1. Null Pointers

A null pointer points to nothing. It is declared using nullptr (C++11 and later).

Example:

#include <iostream>
using namespace std;

int main() {
    int *ptr = nullptr;
    if (ptr == nullptr) {
        cout << "Pointer is null." << endl;
    }
    return 0;
}

Output:

Pointer is null.

2. Void Pointers (Generic Pointers)

A void pointer can store the address of any data type but cannot be dereferenced directly.

Example:

#include <iostream>
using namespace std;

int main() {
    int num = 42;
    void *ptr = &num;  // Void pointer pointing to an integer

    // Dereferencing after typecasting
    cout << "Value of num: " << *(int *)ptr << endl;
    return 0;
}

Output:

Value of num: 42

3. Dangling Pointers

A dangling pointer points to a memory location that has been freed.

Example:

#include <iostream>
using namespace std;

int* createPointer() {
    int a = 10;
    return &a;  // Returning address of a local variable (Dangling)
}

int main() {
    int *ptr = createPointer();
    cout << "Dangling pointer value: " << *ptr << endl; // Undefined behavior
    return 0;
}

4. Constant Pointers and Pointers to Constants

• Constant Pointer: A pointer that cannot change the address it points to.
• Pointer to Constant: A pointer that cannot change the value of the data it points to.

int value = 10;
const int *ptr1 = &value; // Pointer to constant
int *const ptr2 = &value; // Constant pointer

5. Pointer to Pointer (Double Pointer)

A pointer that stores the address of another pointer.

Example:

#include <iostream>
using namespace std;

int main() {
    int value = 20;
    int *ptr = &value;
    int **ptr2 = &ptr;

    cout << "Value: " << value << endl;
    cout << "Pointer value: " << *ptr << endl;
    cout << "Double Pointer value: " << **ptr2 << endl;

    return 0;
}

Output:

Value: 20
Pointer value: 20
Double Pointer value: 20

Dynamic Memory Management (Using Pointers)

Dynamic memory is allocated using the new keyword and freed using delete.

Example:

#include <iostream>
using namespace std;

int main() {
    int *ptr = new int;  // Allocate memory
    *ptr = 100;
    cout << "Dynamically allocated value: " << *ptr << endl;

    delete ptr; // Free memory
    return 0;
}

Output:

Dynamically allocated value: 100

What are References in C++?

A reference is an alias for another variable. It must be initialized when declared and cannot be changed later.

Syntax:

data_type &reference_name = variable_name;

Example:

#include <iostream>
using namespace std;

int main() {
    int value = 50;
    int &ref = value; // Reference to value

    cout << "Value: " << value << endl;
    cout << "Reference: " << ref << endl;

    ref = 100;  // Changing value using reference
    cout << "Updated Value: " << value << endl;

    return 0;
}

Output:

Value: 50
Reference: 50
Updated Value: 100

Key Differences Between Pointers and References

Summary

In this tutorial, you learned:

• What pointers are, how they work, and their different types.
• How to use pointers for dynamic memory management.
• What references are and their differences from pointers.
• Practical examples of pointers and references in C++.