What are and how to use functions in C++

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

Functions allow us to break the code into more manageable chunks (this allows us to create more reusable code and improve the readability and maintainability of the program).

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 these 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, 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 that are values passed to the function for it to process. These parameters are defined in the function declaration and are used within 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 the need 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 performing a normal call). This can improve performance in small, frequently invoked 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;
}

:::::::