C++ Pointers Exercises: Beginner to Advanced

#include <iostream>

int main() {
    int value = 100;
    int* ptr;

    // 1. Assign the address of 'value' to 'ptr'
    ptr = &value;

    // 2. Print the value using the pointer and dereference operator
    std::cout << "The value is: " << *ptr << std::endl; 

    return 0;
}Code language: C++ (cpp)

Explanation:

• The line int* ptr; declares a pointer variable named ptr that is designed to hold the memory address of an integer.
• The line ptr = &value; uses the address-of operator (&) to load the actual memory address of value into the pointer ptr.
• Finally, *ptr is the dereference operation, which follows the pointer’s address to retrieve the data (the integer 100) stored at that location.

#include <iostream>

int main() {
    int number = 50;
    int* num_ptr = &number;

    // Change the value of 'number' using only the pointer
    *num_ptr = 99;

    // Print the final value of the variable 'number'
    std::cout << "The final value of number is: " << number << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The statement int* num_ptr = &number; initializes the pointer to hold the address of number.
• The key line is *num_ptr = 99;. The *num_ptr expression refers to the data at the address stored in num_ptr (which is the variable number). Assigning 99 to this expression directly modifies the content of the variable number itself.

#include <iostream>

int main() {
    int x = 42;
    int* p1 = &x;       // p1 points to x
    int** p2 = &p1;     // p2 points to p1

    // Access the value of x using the double pointer p2
    std::cout << "The value accessed via double pointer is: " << **p2 << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The pointer p1 holds the address of x. The double pointer p2 holds the address of p1.
• The expression *p2 dereferences p2, which results in the content of p1 (the address of x).
• The expression **p2 then dereferences this result (the address of x), which finally gives us the integer value 42 stored in x.
• This structure is used in more complex data structures or when implementing pass-by-reference for pointers.

#include <iostream>

int main() {
    int data[] = {10, 20, 30, 40, 50};
    int size = sizeof(data) / sizeof(data[0]);

    // Initialize pointer to the start of the array
    int* data_ptr = data; 
    
    std::cout << "Elements using pointer increment: ";

    for (int i = 0; i < size; ++i) {
        // Print the value the pointer currently points to
        std::cout << *data_ptr << " "; 
        
        // Move the pointer to the next element
        data_ptr++;             
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The line int* data_ptr = data; initializes the pointer to the base address of the array. Inside the loop, *data_ptr accesses the current element.
• The key operation is data_ptr++. Since data_ptr is an integer pointer, this operation adds sizeof(int) bytes to the address, effectively moving the pointer to the memory address of the next integer element in the array.

#include <iostream>

int main() {
    int scores[] = {85, 90, 78, 95, 88};
    
    // Pointer points to the first element (scores[0])
    int* score_ptr = scores; 

    // Access the third element (index 2) using pointer arithmetic
    int third_element = *(score_ptr + 2);

    std::cout << "The value of the third element is: " << third_element << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The expression score_ptr + 2 performs pointer arithmetic, calculating the address of scores[2] by adding two times the size of an integer to the base address.
• The outer dereference operator (*) then retrieves the value (78) at that calculated memory address. This demonstrates that using scores[i] is functionally equivalent to using *(scores + i).

#include <iostream>

int main() {
    char word[] = "CODE";
    char* p = word; 

    // Access the third character (index 2)
    char third_char = *(p + 2);

    std::cout << "The third character is: " << third_char << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• This confirms that pointer arithmetic works the same way for char arrays as it does for int arrays.
• Since char is typically 1 byte, p + 2 moves the pointer exactly two bytes forward to the memory location of the third character.

#include <iostream>

int main() {
    int* safe_ptr = nullptr;

    if (safe_ptr == nullptr) {
        std::cout << "Pointer is null, cannot dereference." << std::endl;
        
        // Safely assign a valid address for the second check
        int valid_data = 77;
        safe_ptr = &valid_data;
    } 

    // Now, we can safely check again and dereference if assigned
    if (safe_ptr != nullptr) {
        std::cout << "Pointer is now valid. Dereferenced value: " << *safe_ptr << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The initialization int* safe_ptr = nullptr; explicitly sets the pointer to a known, invalid state. The first if statement checks this state using safe_ptr == nullptr.
• This is a crucial safety check to prevent crashes. The second part demonstrates assigning a valid address (&valid_data) and then safely using the pointer only after verifying it’s no longer null.

#include <iostream>

// Function accepts a pointer and modifies the original value
void increment_value(int* ptr) {
    if (ptr != nullptr) {
        // Dereference the pointer to access and change the value
        *ptr += 10; 
    }
}

int main() {
    int counter = 50;

    std::cout << "Before increment: " << counter << std::endl;

    // Pass the address of 'counter'
    increment_value(&counter);

    std::cout << "After increment: " << counter << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise is a basic demonstration of pass-by-pointer.
• By passing the address (&counter), the function receives a pointer (ptr) that allows it to directly access and modify the original variable (counter) in the calling function’s memory space, which is impossible with standard pass-by-value.

#include <iostream>

int main() {
    int i = 0;
    int* ptr = &i;

    std::cout << "Size of an int variable: " << sizeof(i) << " bytes" << std::endl;
    std::cout << "Size of an int pointer (address): " << sizeof(ptr) << " bytes" << std::endl;

    return 0;
}

/* Expected Output on a typical 64-bit system:
Size of an int variable: 4 bytes
Size of an int pointer (address): 8 bytes
*/Code language: C++ (cpp)

Explanation:

• The sizeof(i) reports the size required to store the actual integer data (usually 4 bytes).
• The sizeof(ptr) reports the size required to store a memory address itself. This size is determined by the system’s architecture (32-bit or 64-bit).
• The key takeaway is that the size of a pointer is constant regardless of the type it points to, because it only stores an address.

#include <iostream>

int main() {
    int arr[] = {1, 5, 10, 15, 20};
    int size = sizeof(arr) / sizeof(arr[0]);
    int sum = 0;

    // The array name 'arr' decays to a pointer to the first element
    int* arr_ptr = arr; 

    for (int i = 0; i < size; ++i) {
        // Access element using pointer arithmetic: *(arr_ptr + i)
        sum += *(arr_ptr + i); 
    }

    std::cout << "The sum of array elements is: " << sum << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The pointer arr_ptr holds the base address of the array. The expression arr_ptr + i performs scaled pointer arithmetic, calculating the memory address of the element at the current index i.
• The dereference operator (*) then retrieves the integer value at that address, which is accumulated in sum. This explicitly demonstrates how pointers are used to traverse arrays in C++.

#include <iostream>

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    // Pointer to the first element (the base address)
    int* start_ptr = numbers; 

    // Calculate the address of the LAST element: &numbers[size - 1]
    int* current_ptr = start_ptr + (size - 1); 

    std::cout << "Elements in reverse order: ";

    // Loop backward while the current pointer is >= the start pointer
    while (current_ptr >= start_ptr) {
        std::cout << *current_ptr << " ";
        current_ptr--; // Decrement the pointer to move to the previous element
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The pointer current_ptr is initialized to the address of the last array element. The while loop checks that the pointer is still within the array bounds.
• The core operation is current_ptr--, which moves the pointer backward by sizeof(int) bytes, effectively pointing to the memory location of the previous element, allowing the array to be traversed and printed in reverse order.

#include <iostream>

// Function that returns a pointer to the smallest integer
int* find_min_ptr(int arr[], int size) {
    if (size == 0) {
        return nullptr; // Handle empty array case
    }
    
    // Initialize the minimum pointer to the first element
    int* min_ptr = arr; 

    for (int i = 1; i < size; ++i) {
        // Compare the value pointed to by the current array index (arr[i])
        // with the value pointed to by min_ptr (*min_ptr)
        if (arr[i] < *min_ptr) {
            // Update the pointer to point to the new minimum element
            min_ptr = &arr[i]; 
        }
    }
    return min_ptr;
}

int main() {
    int data[] = {45, 12, 67, 8, 33};
    int size = sizeof(data) / sizeof(data[0]);

    int* min_element_ptr = find_min_ptr(data, size);

    if (min_element_ptr != nullptr) {
        std::cout << "The smallest element is: " << *min_element_ptr << std::endl;
    } else {
        std::cout << "The array is empty." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function find_min_ptr is designed to return an int*. It initializes min_ptr to the start of the array. Inside the loop, it compares the current element (arr[i]) with the value pointed to by min_ptr (*min_ptr).
• If a smaller value is found, min_ptr is updated using the address-of operator (&) to point to the new minimum element’s location (&arr[i]).
• The main function then dereferences the returned pointer to get the actual minimum value (8).

#include <iostream>

int main() {
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    // Calculate total elements
    const int ROWS = 3;
    const int COLS = 3;
    const int TOTAL_ELEMENTS = ROWS * COLS;

    // The array name 'matrix' can be cast or implicitly converted 
    // to a pointer to the first element's data type (int*) for contiguous access
    int* ptr = (int*)matrix; 

    std::cout << "2D Array elements accessed contiguously:" << std::endl;
    for (int i = 0; i < TOTAL_ELEMENTS; ++i) {
        // Access the element using pointer arithmetic
        std::cout << *(ptr + i) << " "; 
        
        // Add a newline after every row (every 3 elements)
        if ((i + 1) % COLS == 0) {
            std::cout << std::endl;
        }
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The line int* ptr = (int*)matrix; casts the 2D array’s starting address to a simple integer pointer (int*).
• Since the array elements are stored sequentially in memory, we can use a single loop iterating from 0 to 8. In each iteration, ptr + i calculates the address of the i-th element from the start, and *(ptr + i) retrieves its value. This highlights how multi-dimensional arrays are physically arranged in memory.

#include <iostream>

// Function to copy source array to destination array using pointers
void copy_array(int* dest, const int* src, int size) {
    for (int i = 0; i < size; ++i) {
        // Copy value from source address to destination address
        *(dest + i) = *(src + i); 
    }
}

int main() {
    const int SIZE = 5;
    int source[] = {10, 20, 30, 40, 50};
    int destination[SIZE]; // Array to receive the copy

    copy_array(destination, source, SIZE);

    std::cout << "Destination array contents: ";
    for (int i = 0; i < SIZE; ++i) {
        std::cout << destination[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function parameters are defined as pointers (int* dest, const int* src), which are the typical way to pass arrays to functions in C++.
• The const keyword on the source pointer is good practice, indicating that the source data will not be modified. The core logic *(dest + i) = *(src + i); dereferences the i-th element of the source array to get its value, and then assigns that value to the location pointed to by the i-th address of the destination array.

#include <iostream>

// Function to compare two arrays using pointers
bool compare_arrays(const int* arr1, const int* arr2, int size) {
    for (int i = 0; i < size; ++i) {
        // Access elements using pointer arithmetic and dereference
        if (*(arr1 + i) != *(arr2 + i)) {
            return false; // Found a difference
        }
    }
    return true; // No differences found
}

int main() {
    const int SIZE = 4;
    int a1[] = {1, 2, 3, 4};
    int a2[] = {1, 2, 3, 4};
    int a3[] = {1, 2, 9, 4};

    // Compare a1 and a2 (Identical)
    if (compare_arrays(a1, a2, SIZE)) {
        std::cout << "Array a1 and a2 are identical." << std::endl;
    } else {
        std::cout << "Array a1 and a2 are NOT identical." << std::endl;
    }

    // Compare a1 and a3 (Different)
    if (compare_arrays(a1, a3, SIZE)) {
        std::cout << "Array a1 and a3 are identical." << std::endl;
    } else {
        std::cout << "Array a1 and a3 are NOT identical." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function compare_arrays takes constant pointers to ensure the original arrays aren’t accidentally modified.
• It loops from i=0 up to size-1. The check if (*(arr1 + i) != *(arr2 + i)) compares the values at the current memory addresses in both arrays. If the values differ, the function immediately terminates and returns false.
• This early exit optimization is efficient. If the loop finishes, it means all elements matched, and true is returned.

#include <iostream>

void print_sub_array(int* arr, int start, int end) {
    // Calculate the pointer to the start of the sub-range
    int* current_ptr = arr + start; 
    
    // Calculate the pointer to one element PAST the end of the sub-range
    int* end_ptr = arr + end; 
    
    std::cout << "Sub-array elements: ";
    
    // Loop while the current pointer has not reached the end pointer
    while (current_ptr < end_ptr) {
        std::cout << *current_ptr << " ";
        current_ptr++;
    }
    std::cout << std::endl;
}

int main() {
    int data[] = {10, 20, 30, 40, 50, 60};
    int start_index = 2; // Element 30
    int end_index = 5;   // Up to element 50 (exclusive)

    print_sub_array(data, start_index, end_index); // Expected: 30 40 50 

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function first calculates the starting and ending addresses for the print range using pointer arithmetic (arr + start and arr + end).
• The while loop uses the addresses themselves for the boundary condition (current_ptr < end_ptr). Inside the loop, *current_ptr prints the value, and current_ptr++ moves the pointer to the next element.
• This technique is common in C++ iterators, where ranges are defined by a starting pointer (or iterator) and an exclusive ending pointer.

#include <iostream>

// Function to swap the values pointed to by p1 and p2
void swap(int* p1, int* p2) {
    int temp = *p1; // Store the value at p1's address
    *p1 = *p2;      // Assign the value at p2's address to p1's address
    *p2 = temp;     // Assign the stored value (original p1) to p2's address
}

int main() {
    int a = 10;
    int b = 20;

    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;

    // Pass the addresses of a and b to the function
    swap(&a, &b);

    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This is the classic example of pass-by-pointer, which allows a function to modify variables defined in the calling function (main). When swap(&a, &b) is called, the addresses of a and b are passed.
• Inside swap, the pointers p1 and p2 hold these addresses. By using the dereference operator (*p1 and *p2), the function accesses and changes the values of the variables a and b directly in the main function’s memory space.

#include <iostream>
#include <cctype>

// Function to convert a C-style string to uppercase in place
void to_uppercase(char* str_ptr) {
    // Loop until the null-terminator is reached
    while (*str_ptr != '\0') {
        // Use toupper() to convert the character and assign it back 
        // to the memory location pointed to by str_ptr
        *str_ptr = std::toupper(*str_ptr); 
        
        // Move the pointer to the next character
        str_ptr++; 
    }
}

int main() {
    // Note: Must be char array, not const char* literal, to allow modification
    char text[] = "hello pointers exercise"; 

    std::cout << "Original: " << text << std::endl;
    
    to_uppercase(text);
    
    std::cout << "Uppercase: " << text << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function to_uppercase accepts the string’s base address via char* str_ptr. The while loop uses the dereferenced value (*str_ptr) as its condition, ensuring it stops at the null-terminator.
• The assignment *str_ptr = std::toupper(*str_ptr); modifies the character at the current memory location.
• Since the function is passed the address of the original array (text), the changes are permanent and visible in main. The str_ptr++ moves the pointer to the next memory address (one byte further).

#include <iostream>

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

int main() {
    // 1. Declare a function pointer named 'op_ptr'
    int (*op_ptr)(int, int);

    // 2. Assign the 'add' function's address to the pointer
    op_ptr = add; 

    // 3. Call the function using the pointer (dereference is optional but good practice)
    int result1 = op_ptr(10, 5); 
    int result2 = (*op_ptr)(25, 75); // Equivalent call using explicit dereference

    std::cout << "Result 1 (10 + 5): " << result1 << std::endl;
    std::cout << "Result 2 (25 + 75): " << result2 << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The line int (*op_ptr)(int, int); declares op_ptr as a pointer that can store the address of any function that takes two ints and returns an int.
• Assignment is simple: op_ptr = add; (the function name decays to its address).
• Calling the function via the pointer (op_ptr(10, 5)) is virtually identical to calling the function directly. Function pointers are essential for implementing callback functions and designing flexible interfaces.

#include <iostream>

// Type definition for easier readability of the function pointer signature
typedef int (*OperationPtr)(int, int);

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

int subtract(int a, int b) {
    return a - b;
}

// Function that takes a function pointer (callback) as an argument
int compute_result(int val1, int val2, OperationPtr operation) {
    // Call the function pointed to by 'operation'
    return operation(val1, val2); 
}

int main() {
    int x = 50;
    int y = 10;

    // Pass the multiply function's address (decayed name)
    int product = compute_result(x, y, multiply);
    std::cout << "Multiplication result: " << product << std::endl; 

    // Pass the subtract function's address (decayed name)
    int difference = compute_result(x, y, subtract);
    std::cout << "Subtraction result: " << difference << std::endl; 

    return 0;
}Code language: C++ (cpp)

Explanation:

• The typedef makes the function pointer signature more readable. The compute_result function is designed as a generic interface. It doesn’t know which operation it will perform until runtime.
• When called, the multiply or subtract function’s address is passed. Inside compute_result, the line return operation(val1, val2); executes the function currently pointed to by operation.
• This pattern is known as a callback and allows for highly flexible and extensible code design.

#include <iostream>

// Function accepts a pointer to constant data
void print_constant_value(const int* ptr) {
    if (ptr != nullptr) {
        std::cout << "Value via const pointer: " << *ptr << std::endl;
        
        // ** Attempting to modify the value here will cause a compile error **
        // *ptr = 500; 
        // Uncommenting the line above results in: 
        // error: assignment of read-only location ‘*ptr’
    }
}

int main() {
    int data = 100;
    
    // The pointer itself is not constant, but the data is treated as such
    print_constant_value(&data);

    // We can still modify 'data' directly because it's not constant
    data = 200;
    print_constant_value(&data);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function signature const int* ptr declares a pointer to constant data. This means that although the variable data in main is not constant, the function guarantees it will treat the data pointed to by ptr as read-only.
• This is a crucial safety mechanism: it allows the function to read data without the risk of accidental modification. The compiler prevents the assignment *ptr = 500 because it violates the const contract specified in the function parameter.

#include <iostream>

int main() {
    int x = 5;
    int y = 25;
    
    // Constant pointer: must always point to the address of 'x'
    int* const const_ptr = &x; 

    // 1. SUCCESS: We can modify the data 'x' via the pointer
    *const_ptr = 10;
    std::cout << "x after modification via pointer: " << x << std::endl; // Prints 10

    // 2. FAILURE: Attempting to change the pointer itself
    // const_ptr = &y; 
    // Uncommenting the line above results in: 
    // error: assignment of read-only variable ‘const_ptr’

    return 0;
}Code language: C++ (cpp)

Explanation:

• The declaration int* const const_ptr = &x; defines a constant pointer. The const modifier is placed after the asterisk, making the pointer address itself immutable.
• Thus, the pointer must always point to the address of x and cannot be reassigned to point to y. However, since the data type (int) is not constant, the value at the address (i.e., x) can be freely changed using the dereference operator (*const_ptr = 10).

#include <iostream>

struct Rectangle {
    int length;
    int width;
};

int main() {
    Rectangle rect = {10, 5};
    
    // Declare and initialize a pointer to the structure
    Rectangle* rect_ptr = &rect; 

    std::cout << "Original dimensions: " << rect_ptr->length 
              << " x " << rect_ptr->width << std::endl;

    // Modify members using the arrow operator
    rect_ptr->length = 15;
    rect_ptr->width = 7;

    std::cout << "New dimensions: " << rect.length 
              << " x " << rect.width << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The line Rectangle* rect_ptr = ▭ sets up the structure pointer.
• The arrow operator (->) is used to access members through the pointer, such as rect_ptr->length. This operator automatically dereferences the pointer and accesses the specified member, making code much cleaner than using the verbose (*rect_ptr).length syntax.
• This is fundamental when working with linked lists or dynamic objects in C++

#include <iostream>

int main() {
    // Dynamically allocate a single float on the heap
    float* float_ptr = new float; 
    
    // Check if allocation was successful (optional but good practice)
    if (float_ptr == nullptr) {
        std::cerr << "Memory allocation failed!" << std::endl;
        return 1;
    }

    // Initialize the allocated memory
    *float_ptr = 3.14f;

    std::cout << "Dynamically allocated float value: " << *float_ptr << std::endl;
    std::cout << "Address on heap: " << float_ptr << std::endl;

    // Deallocate the memory to prevent memory leak
    delete float_ptr;
    
    // Set the pointer to nullptr after deletion to avoid dangling pointer issues
    float_ptr = nullptr;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The statement float* float_ptr = new float; allocates enough memory on the heap to hold a single float and stores the starting address in float_ptr.
• The value is set using dereference: *float_ptr = 3.14f;. Crucially, delete float_ptr; returns the allocated memory back to the system, preventing a memory leak.
• Setting the pointer to nullptr after deletion is important to avoid a dangling pointer—a pointer that still holds the address of deallocated memory.

#include <iostream>

int main() {
    const int SIZE = 8;
    
    // Dynamically allocate an array of 8 integers on the heap
    int* array_ptr = new int[SIZE]; 

    // Fill the array using pointer arithmetic
    for (int i = 0; i < SIZE; ++i) {
        *(array_ptr + i) = (i + 1) * 10;
    }

    // Print the array using pointer traversal
    std::cout << "Dynamically allocated array: ";
    for (int i = 0; i < SIZE; ++i) {
        std::cout << array_ptr[i] << " "; // Using [] is fine after allocation
    }
    std::cout << std::endl;

    // Crucial step: Deallocate the entire array
    delete[] array_ptr;
    array_ptr = nullptr;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The statement int* array_ptr = new int[SIZE]; allocates a contiguous block of memory large enough for 8 integers.
• We then treat array_ptr just like a regular array name. The loop fills the elements using pointer arithmetic. The command delete[] array_ptr; is mandatory for arrays.
• The square brackets inform the C++ runtime that it needs to run destructors (if applicable) and deallocate the entire contiguous block, not just the memory for the first element.

#include <iostream>

int main() {
    int n1 = 10;
    int n2 = 20;
    int n3 = 30;
    int n4 = 40;
    int n5 = 50;

    // Declare an array of 5 integer pointers
    int* array_of_ptrs[5];

    // Assign the address of each integer to an element in the pointer array
    array_of_ptrs[0] = &n1;
    array_of_ptrs[1] = &n2;
    array_of_ptrs[2] = &n3;
    array_of_ptrs[3] = &n4;
    array_of_ptrs[4] = &n5;

    std::cout << "Values via array of pointers: ";
    for (int i = 0; i < 5; ++i) {
        // Dereference the pointer stored at index i
        std::cout << *array_of_ptrs[i] << " "; 
    }
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The declaration int* array_of_ptrs[5]; creates an array on the stack where each of the five slots is designed to hold a memory address (an int*).
• We populate this array with the addresses of the five stack variables. In the loop, array_of_ptrs[i] retrieves the stored address, and the leading * operator retrieves the value from that address. This structure is often used to manage a collection of scattered data efficiently.

#include <iostream>

// Returns a pointer to the first occurrence of target in source, or nullptr
char* find_first_occurrence(const char* source, const char* target) {
    if (*target == '\0') return (char*)source; // Empty target is a special case
    
    const char* current_source = source;
    
    // Outer loop: Iterate through the source string
    while (*current_source != '\0') {
        const char* s = current_source;
        const char* t = target;
        
        // Inner loop: Compare characters from current position
        while (*t != '\0' && *s == *t) {
            s++;
            t++;
        }
        
        // Check if the inner loop reached the end of the target string
        if (*t == '\0') {
            return (char*)current_source; // Match found, return the start address
        }

        current_source++; // Move to the next character in the source
    }

    return nullptr; // No match found
}

int main() {
    const char* main_str = "programming in c++ is fun";
    const char* sub_str = "c++";

    char* found_ptr = find_first_occurrence(main_str, sub_str);

    if (found_ptr != nullptr) {
        std::cout << "Substring found starting at: " << found_ptr << std::endl;
        std::cout << "Source string starting from match: " << found_ptr << std::endl;
    } else {
        std::cout << "Substring not found." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This function uses multiple pointers to manage the search. current_source tracks the starting point in the main string.
• The inner pointers (s and t) perform the character-by-character comparison. If the inner while loop completes because *t hit the null-terminator (\0), it means a full match was found.
• The function then returns current_source, the address where the match began. If the outer loop finishes, the function returns nullptr, indicating no match.

#include <iostream>

void leak_memory(int count) {
    std::cout << "Allocating " << count << " integers without deletion..." << std::endl;
    
    for (int i = 0; i < count; ++i) {
        // A temporary pointer is created
        int* temp_ptr = new int(i); 
        
        // The pointer goes out of scope at the end of the loop iteration, 
        // losing the only reference to the memory block it pointed to.
        // We MUST call delete temp_ptr; here, but we are intentionally skipping it.
    }

    // All 100 memory blocks are now "leaked"
    std::cout << "Memory leak simulated. The system is holding inaccessible memory." << std::endl;
}

int main() {
    leak_memory(100);
    // The program will finish, but the operating system won't reclaim the 
    // memory until the entire process terminates.
    return 0;
}Code language: C++ (cpp)

Explanation:

• Inside the loop, int* temp_ptr = new int(i); allocates a block of heap memory.
• When the loop iterates to the next cycle, the local variable temp_ptr is destroyed (it goes out of scope). However, the memory block it pointed to on the heap remains allocated.
• Since temp_ptr was the only variable holding the address of that block, the program has lost the ability to call delete.
• This inaccessible memory is a memory leak, reducing the available memory until the program terminates and the operating system automatically reclaims it.

#include <iostream>

// Returns a pointer to the new array, requires size updates in calling code
int* resize_array(int* old_array, int old_size, int new_size) {
    // 1. Create a new, larger array
    int* new_array = new int[new_size]; 

    // 2. Copy contents from old array to new array using pointers
    for (int i = 0; i < old_size; ++i) {
        *(new_array + i) = *(old_array + i);
    }
    
    // 3. Clean up the old array memory
    delete[] old_array; 

    return new_array;
}

int main() {
    int old_size = 5;
    int new_size = 10;
    
    // Initial dynamic allocation
    int* data_ptr = new int[old_size]{1, 2, 3, 4, 5}; 

    std::cout << "Original array (size 5): ";
    for (int i = 0; i < old_size; ++i) std::cout << data_ptr[i] << " ";
    std::cout << std::endl;

    // Simulate reallocation
    data_ptr = resize_array(data_ptr, old_size, new_size);
    old_size = new_size; // Update size tracking variable

    // The new array has copied data and new uninitialized space
    std::cout << "Resized array (size 10): ";
    for (int i = 0; i < old_size; ++i) {
        std::cout << (data_ptr[i] == 0 ? 99 : data_ptr[i]) << " "; // Print 99 for uninitialized
    }
    std::cout << std::endl;

    delete[] data_ptr;
    return 0;
}Code language: C++ (cpp)

Explanation:

• C++ does not have a built-in realloc like C. This function demonstrates the manual process: allocate new memory (new int[new_size]), copy data, and deallocate old memory (delete[] old_array).
• The key challenge is ensuring the old pointer is correctly deleted, and the new pointer (the base address of the larger block) is correctly returned and used to update the pointer variable (data_ptr) in main.
• This is the fundamental mechanism behind C++ container classes like std::vector when they grow in size.

#include <iostream>

struct Node {
    int data;
    Node* next; // Pointer to the next node in the list
};

int main() {
    // 1. Create three nodes dynamically
    Node* n1 = new Node{10, nullptr};
    Node* n2 = new Node{20, nullptr};
    Node* n3 = new Node{30, nullptr};

    // 2. Link them sequentially
    n1->next = n2; // n1 points to n2
    n2->next = n3; // n2 points to n3
    // n3->next is already nullptr

    // 3. Traverse the list starting from the head (n1)
    Node* current = n1;
    
    std::cout << "Linked List Traversal: ";
    while (current != nullptr) {
        std::cout << current->data << " ";
        current = current->next; // Move to the next node using the pointer
    }
    std::cout << std::endl;

    // 4. Clean up (essential for dynamic structures)
    current = n1;
    while (current != nullptr) {
        Node* next_node = current->next;
        delete current;
        current = next_node;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates the core concept of a linked list, which relies entirely on pointers. The Node structure is self-referential because it contains a pointer to its own type.
• The links are established by setting the next pointer of one node to the address of the subsequent node (e.g., n1->next = n2;). Traversal starts at the head (n1) and moves forward by continually updating the current pointer to the value stored in current->next.
• The cleanup phase is critical: memory must be deallocated node by node to avoid leaks.