What are and how to use functions in C++

In C++, functions are reusable blocks of code that perform specific tasks and can be invoked from other parts of the program.

Functions allow dividing code into more manageable fragments (this allows us to create more reusable code and improve the program’s readability and maintainability).

What is a function

A function in C++ is a set of instructions that performs a specific task. A function can be defined to receive certain parameters, process this data, and return a result if necessary. The basic structure of a function in C++ is as follows:

return_type function_name(parameter_type parameter1, parameter_type parameter2, ...)
{
    // Function code
    return return_value; // Optional
}

Basic example

Let’s look at a basic example of a function in C++ that adds two numbers:

#include <iostream>

int Add(int num1, int num2) {
    return num1 + num2;
}

int main() {
    int result = Add(5, 3);
    std::cout << "The sum is: " << result << std::endl;
    return 0;
}

Calling functions

To call a function, you simply use its name followed by parentheses containing the necessary arguments (if any). Here is an example of calling the Add function:

int result = Add(5, 3);

Parameters

Functions in C++ can accept parameters, which are values passed to the function for it to process. These parameters are defined in the function declaration and are used inside the function to perform calculations or manipulations.

For example, the following function calculates the area of a rectangle given its width and height:

double CalculateRectangleArea(double width, double height) {
    return width * height;
}

Return value

Functions can return a value using the return keyword. The type of value returned must match the return type specified in the function declaration.

For example, the following function calculates the area of a circle given its radius:

#include <cmath> // For the constant M_PI

double CalculateCircleArea(double radius) {
    return M_PI * radius * radius;
}

Functions without return

If a function does not return any value, the return type void is used. These functions are generally used to perform actions without needing to return a result.

For example, a function that prints a message to the console:

void PrintMessage(const std::string& message) {
    std::cout << message << std::endl;
}

Inline functions

inline functions suggest to the compiler to expand the function’s code at the call site (instead of making a normal function call). This can improve performance for small, frequently called functions.

inline int sum(int a, int b) {
    return a + b;
}

Recursive functions

A function is recursive if it calls itself. Recursion is useful for solving problems that can be divided into smaller subproblems of the same type.

#include <iostream>

int factorial(int n) {
    if (n <= 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int number = 5;
    std::cout << "The factorial of " << number << " is " << factorial(number) << std::endl;
    return 0;
}

Practical examples

std::string EvenOdd(int number) {
    if (number % 2 == 0) {
        return "even";
    } else {
        return "odd";
    }
}

#include <cmath> // For the constant M_PI

double CalculateCircleArea(double radius) {
    return M_PI * radius * radius;
}

int Maximum(int a, int b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

double CelsiusToFahrenheit(double celsius) {
    return (celsius * 9 / 5) + 32;
}

bool IsPrime(int number) {
    if (number <= 1) return false;
    for (int i = 2; i < number; i++) {
        if (number % i == 0) return false;
    }
    return true;
}

#include <vector>

int SumArray(const std::vector<int>& numbers) {
    int sum = 0;
    for (int number : numbers) {
        sum += number;
    }
    return sum;
}