C++ Functions Exercises: 18 Coding Problems with Solutions

#include <iostream>

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

int main() {
    int num1 = 15;
    int num2 = 27;
    
    // Function call and storing the returned value
    int sum = add(num1, num2);
    
    std::cout << "The sum of " << num1 << " and " << num2 << " is: " << sum << std::endl;
    
    // Another way to call the function
    std::cout << "3 + 7 = " << add(3, 7) << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates passing arguments to a function and using a non-void return type (int).
• The values of num1 (15) and num2 (27) are passed by value to the parameters a and b.
• The function calculates the sum and uses return sum; to send the result back to the main function, where it is stored in the sum variable.

#include <iostream>

// Function definition using Pass by Value
void swap_value(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    
    std::cout << "Inside swap_value function: a = " << a << ", b = " << b << std::endl;
}

int main() {
    int x = 10;
    int y = 20;
    
    std::cout << "Before call: x = " << x << ", y = " << y << std::endl;
    
    swap_value(x, y); // x and y are passed by value (copied)
    
    std::cout << "After call: x = " << x << ", y = " << y << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise is crucial for understanding Pass by Value. When swap_value(x, y) is called, the function receives copies of x (10) and y(20) into its local variables a and b.

The swap successfully happens to a and b inside the function, but the original variables x and y in main remain unchanged.

#include <iostream>

// Function definition using Pass by Reference
void swap_reference(int &a, int &b) {
    int temp = a; // temp holds the value currently in x (10)
    a = b;        // x's value becomes y's value (20)
    b = temp;     // y's value becomes temp (10)
    
    std::cout << "Inside swap_reference function: a = " << a << ", b = " << b << std::endl;
}

int main() {
    int x = 10;
    int y = 20;
    
    std::cout << "Before call: x = " << x << ", y = " << y << std::endl;
    
    swap_reference(x, y); // x and y are passed by reference (alias)
    
    std::cout << "After call: x = " << x << ", y = " << y << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This demonstrates Pass by Reference. By using int &a and int &b, the parameters a and b become aliases for the variables x and y in main.

Any operation performed on a and b is directly performed on x and y. Therefore, the swap operation successfully changes the values of the original variables in the calling function.

#include <iostream>

// Function definition
void print_array(int arr[], int size) {
    std::cout << "Array elements: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int n = sizeof(numbers) / sizeof(numbers[0]); // Calculate size
    
    print_array(numbers, n);
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise demonstrates passing an array to a function.

• When an array is passed as a parameter (int arr[]), it decays into a pointer to its first element. Therefore, its size is lost, and it must be passed separately (int size).
• The function then uses the size and pointer arithmetic (via the array indexing arr[i]) to iterate and access all elements.

#include <iostream>

// Function definition
void set_to_zero(int arr[], int index) {
    // Check for a basic valid index before modifying
    if (index >= 0) {
        arr[index] = 0;
    }
}

int main() {
    int data[] = {1, 2, 3, 4, 5};
    int size = 5;
    int target_index = 2; // We want to change the element '3'
    
    std::cout << "Original Array: ";
    for (int i = 0; i < size; ++i) {
        std::cout << data[i] << " ";
    }
    std::cout << std::endl;
    
    set_to_zero(data, target_index);
    
    std::cout << "Modified Array: ";
    for (int i = 0; i < size; ++i) {
        std::cout << data[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise confirms the behavior seen in the previous exercise: when an array is passed, its contents can be modified within the function because the function operates directly on the memory location of the array elements. The function uses the provided index to specifically target and change a single element to 0.

#include <iostream>

// 1. Function for Rectangle (Two parameters)
double area(double length, double width) {
    return length * width;
}

// 2. Overloaded Function for Square (One parameter)
double area(double side) {
    return side * side;
}

int main() {
    // Call 1: Rectangle area (uses the 2-parameter function)
    double rect_area = area(10.0, 5.0);
    std::cout << "Area of rectangle (10x5): " << rect_area << std::endl;
    
    // Call 2: Square area (uses the 1-parameter function)
    double sq_area = area(7.0);
    std::cout << "Area of square (7x7): " << sq_area << std::endl;

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

Explanation:

• This exercise demonstrates Function Overloading. The C++ compiler determines which version of the area function to call based on the number of arguments provided during the function call.
• When two arguments are provided (area(10.0, 5.0)), the two-parameter version is executed.
• When one argument is provided (area(7.0)), the single-parameter version is executed.

#include <iostream>
#include <cmath> // For std::pow

// Function definition with a default argument
double power(double base, int exponent = 2) {
    // Note: C++ allows default arguments only once (in the declaration or definition).
    return std::pow(base, exponent);
}

int main() {
    // Call 1: Explicit exponent (7^3)
    double result1 = power(7.0, 3);
    std::cout << "7 raised to 3: " << result1 << std::endl; // Output: 343
    
    // Call 2: Default exponent (5^2)
    double result2 = power(5.0); 
    std::cout << "5 squared (default): " << result2 << std::endl; // Output: 25

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

Explanation:

• This exercise demonstrates Default Arguments. By setting exponent = 2 in the parameter list, the compiler automatically substitutes 2 if the caller omits the second argument.
• This makes the function more flexible and reduces the need for overloading in cases where one argument is frequently used.

#include <iostream>

// Recursive function definition
long long factorial(int n) {
    // Base Case: stops the recursion
    if (n == 0) {
        return 1;
    }
    // Recursive Step: calls itself with a smaller input
    return n * factorial(n - 1);
}

int main() {
    int number = 5;
    long long result = factorial(number);
    
    std::cout << number << "! is: " << result << std::endl; // Output: 120
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• This is a classic example of Recursion, where a function calls itself.
• Every recursive function must have a base case (if (n == 0)) to prevent infinite calls, and a recursive step (n * factorial(n - 1)) that moves the input closer to the base case.
• The function breaks the problem (finding 5!) into a smaller problem (finding 4!) until it reaches the solvable base case (0!).

#include <iostream>

// Recursive function definition
int fibonacci(int n) {
    // Base Case 1
    if (n == 0) {
        return 0;
    }
    // Base Case 2
    if (n == 1) {
        return 1;
    }
    // Recursive Step
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    int index = 8; 
    int result = fibonacci(index);
    
    // F(8) is 21
    std::cout << "The " << index << "th Fibonacci number is: " << result << std::endl; 
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• The two base cases (n=0 and n=1) are crucial as they provide the starting values and prevent infinite calls.
• The recursive step breaks the original problem into two smaller, identical sub-problems (finding the preceding two numbers), and the process continues until all branches hit a base case.

#include <iostream>

// Function defined as inline
inline int add(int a, int b) {
    return a + b;
}

int main() {
    int x = 15;
    int y = 5;
    std::cout << "x:" << x <<" y:" <<y << std::endl;
    // The compiler is requested to replace this call with the function body. 
    int result = add(x, y); 
    
    std::cout << "Inline add result: " << result << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• The inline keyword suggests that the compiler perform function substitution (or “inlining”) at the call site rather than generating a normal function call.
• This avoids the overhead associated with function calls, which can improve performance for small, frequently called functions.

#include <iostream>

// Target function
int max_of_two(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    // Declaration and initialization of a function pointer
    int (*ptr_max)(int, int) = max_of_two; 
    
    int x = 45;
    int y = 90;
    
    // Calling the function using the pointer
    int result = ptr_max(x, y); 
    
    std::cout << "Using function pointer, max of " << x << " and " << y << " is: " << result << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

A function pointer stores the memory address of a function, allowing the function to be called indirectly. The declaration defines the pointer as pointing to a function taking two integers and returning an integer.

#include <iostream>

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

// Function that accepts a function pointer as an argument
int execute_operation(int a, int b, int (*operation)(int, int)) {
    return operation(a, b);
}

int main() {
    int num1 = 10;
    int num2 = 3;
    
    // Pass the 'add' function's address
    int sum = execute_operation(num1, num2, add); 
    std::cout << "Addition result (10 + 3): " << sum << std::endl;
    
    // Pass the 'subtract' function's address
    int difference = execute_operation(num1, num2, subtract); 
    std::cout << "Subtraction result (10 - 3): " << difference << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise demonstrates passing a function pointer as a parameter. The function’s behavior is determined entirely by the function passed to it, which is the basis for implementing callback mechanisms.

#include <iostream>
#include <string>

// Function Template definition
template <typename T>
T max_value(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // 1. Using with integers
    std::cout << "Max int: " << max_value(5, 10) << std::endl;
    
    // 2. Using with doubles
    std::cout << "Max double: " << max_value(3.14, 2.71) << std::endl;
    
    // 3. Using with characters
    std::cout << "Max char: " << max_value('z', 'a') << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• A Function Template defines a generic function that can operate on different data types without being rewritten for each type.
• The compiler generates specific versions of the function at compile time, a concept known as generic programming.

#include <iostream>

// Function Template definition
template <typename T>
void swap_generic(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 100;
    int y = 200;
    
    double d1 = 5.5;
    double d2 = 9.9;
    
    swap_generic(x, y); // Swapping integers
    swap_generic(d1, d2); // Swapping doubles
    
    std::cout << "After swap (int): x = " << x << ", y = " << y << std::endl;
    std::cout << "After swap (double): d1 = " << d1 << ", d2 = " << d2 << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This template combines generic programming with pass by reference. By using T& for the parameters, the function can swap any two variables of type T, avoiding code duplication while maintaining efficiency.

#include <iostream>
#include <string>

// Function definition using constant reference
void print_string(const std::string &s) {
    std::cout << "String value (read-only): " << s << std::endl;
    
    // This line would cause a compile-time error:
    // s = "Attempted modification"; 
}

int main() {
    std::string message = "This is a long message.";
    
    print_string(message);
    
    std::cout << "Original string remains: " << message << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

Pass by Constant Reference (const T&) is an optimization. The use of & avoids creating a full copy of the large string object. The use of const guarantees that the function cannot modify the original object, maintaining data integrity.

#include <iostream>
#include <cmath>

bool is_prime(int n) {
    if (n <= 1) return false;
    // Check divisibility up to the square root of n
    for (int i = 2; i <= std::sqrt(n); ++i) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    std::cout << "Prime numbers between 1 and 20:" << std::endl;
    for (int i = 1; i <= 20; ++i) {
        if (is_prime(i)) {
            std::cout << i << " ";
        }
    }
    std::cout << std::endl;
    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise emphasizes function modularity. The complex primality logic is encapsulated within is_prime, allowing the main function to remain clean and readable, focused only on the loop and output

#include <iostream>
#include <vector>

// Function definition: takes const reference
int sum_vector(const std::vector<int> &vec) {
    int total = 0;
    // Range-based for loop for easy iteration
    for (int element : vec) { 
        total += element;
    }
    return total;
}

int main() {
    std::vector<int> data = {10, 20, 30, 40};
    
    int total_sum = sum_vector(data); // Expected sum: 100
    
    std::cout << "The sum of the vector elements is: " << total_sum << std::endl;
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise applies function concepts to the Standard Template Library (STL). By using const reference (const std::vector<int> &), we achieve efficiency (no vector copy) and safety (the function cannot modify the original vector).