Pointers & Memory

1. Basic Pointer Operations

Declaration and Initialization

#include <iostream>
using namespace std;

int main() {
    int num = 10;
    int *ptr;        // Pointer declaration
    ptr = &num;      // Store address of num
    
    cout << "Value of num: " << num << endl;
    cout << "Address of num: " << &num << endl;
    cout << "Value of ptr: " << ptr << endl;
    cout << "Value pointed by ptr: " << *ptr << endl;
    
    return 0;
}

Pointer Operators

• & (Address of): Returns the address of a variable
• * (Dereference): Returns the value at the address stored in pointer

2. Pointer Arithmetic

Pointers can be incremented, decremented, and used in arithmetic operations:

#include <iostream>
using namespace std;

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;  // Points to first element
    
    cout << *ptr << endl;      // 10
    ptr++;                      // Move to next element
    cout << *ptr << endl;      // 20
    ptr += 2;                   // Move 2 elements ahead
    cout << *ptr << endl;      // 40
    
    // Traverse array using pointer
    ptr = arr;
    for (int i = 0; i < 5; i++) {
        cout << *(ptr + i) << " ";
    }
    cout << endl;
    
    return 0;
}

3. Pointers and Arrays

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;
    
    // Array name is a pointer to first element
    cout << "arr = " << arr << endl;
    cout << "&arr[0] = " << &arr[0] << endl;
    cout << "ptr = " << ptr << endl;
    
    // Accessing elements
    cout << arr[2] << endl;      // 3
    cout << *(arr + 2) << endl;  // 3
    cout << ptr[2] << endl;      // 3
    cout << *(ptr + 2) << endl;  // 3
    
    return 0;
}

4. Pointers to Pointers

#include <iostream>
using namespace std;

int main() {
    int num = 10;
    int *ptr = &num;
    int **pptr = &ptr;  // Pointer to pointer
    
    cout << "num = " << num << endl;
    cout << "*ptr = " << *ptr << endl;
    cout << "**pptr = " << **pptr << endl;
    
    return 0;
}

5. Dynamic Memory Allocation

C++ provides new and delete operators for dynamic memory management:

Single Variable

#include <iostream>
using namespace std;

int main() {
    int *ptr = new int;  // Allocate memory
    *ptr = 100;
    
    cout << "Value: " << *ptr << endl;
    
    delete ptr;  // Deallocate memory
    ptr = nullptr;  // Good practice
    
    return 0;
}

Array

#include <iostream>
using namespace std;

int main() {
    int size;
    cout << "Enter size: ";
    cin >> size;
    
    int *arr = new int[size];  // Dynamic array
    
    for (int i = 0; i < size; i++) {
        arr[i] = i * 10;
    }
    
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    delete[] arr;  // Deallocate array
    arr = nullptr;
    
    return 0;
}

6. References

A reference is an alias for an existing variable. Unlike pointers, references cannot be reassigned:

#include <iostream>
using namespace std;

int main() {
    int num = 10;
    int &ref = num;  // Reference to num
    
    cout << "num = " << num << endl;
    cout << "ref = " << ref << endl;
    
    ref = 20;  // Changes num
    cout << "After ref = 20:" << endl;
    cout << "num = " << num << endl;
    cout << "ref = " << ref << endl;
    
    return 0;
}

7. Pointers vs References

8. Function Pointers

#include <iostream>
using namespace std;

int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

int main() {
    int (*funcPtr)(int, int);  // Function pointer
    
    funcPtr = add;
    cout << "Add: " << funcPtr(5, 3) << endl;
    
    funcPtr = multiply;
    cout << "Multiply: " << funcPtr(5, 3) << endl;
    
    return 0;
}

9. Smart Pointers (C++11)

Modern C++ provides smart pointers for automatic memory management:

• unique_ptr: Exclusive ownership, automatically deleted
• shared_ptr: Shared ownership, reference counted
• weak_ptr: Non-owning reference to shared_ptr

#include <iostream>
#include <memory>
using namespace std;

int main() {
    // unique_ptr - automatically deleted
    unique_ptr<int> ptr(new int(10));
    cout << *ptr << endl;
    // Memory automatically freed when ptr goes out of scope
    
    // shared_ptr - reference counted
    shared_ptr<int> sptr1 = make_shared<int>(20);
    shared_ptr<int> sptr2 = sptr1;  // Both point to same memory
    cout << *sptr1 << endl;
            // Memory freed when last shared_ptr is destroyed
    
    return 0;
}