Functions in C++: User-Defined

Definition:

C++ functions are blocks of code that perform specific tasks and can be called from other parts of a program. They provide a way to organize code into reusable modules, making the code more readable, modular, and maintainable. Functions in C++ can have a return type, parameters, and a body that contains the actual code to be executed.

Here is the syntax of a C++ function declaration:

return_type function_name(parameter1, parameter2, ...)
{
    // Function body
    // Code to be executed
}

Let's break down the different components of a C++ function:

1. Return Type: This specifies the type of data that the function will return after its execution. It can be any valid C++ data type, such as `int`, `float`, `void` (indicating no return value), or even a user-defined type. For example, a function that calculates the sum of two numbers and returns the result could have a return type of `int`.

2. Function Name: This is the identifier used to call the function from other parts of the program. The function name should be meaningful and follow the naming conventions of C++. For example, a function that calculates the sum of two numbers could be named `calculateSum`.

3. Parameters: These are optional inputs to the function that allow you to pass values from the calling code into the function. Parameters are enclosed in parentheses after the function name, and multiple parameters are separated by commas. Each parameter consists of a type and a name, specifying the data type of the parameter and a local variable name to be used within the function. For example, a function that calculates the sum of two numbers could have parameters `int num1` and `int num2`.

4. Function Body: This is the block of code enclosed within curly braces `{}` that contains the actual implementation of the function. It consists of statements that define the behavior of the function. These statements can include variable declarations, control flow structures (e.g., if-else, loops), function calls, and any other valid C++ code. The function body is executed when the function is called, and it can manipulate the parameters and local variables defined within the function.

Now, let's see an example of a C++ function that calculates the sum of two numbers:

int calculateSum(int num1, int num2)
{
    int sum = num1 + num2;

    return sum;
}

In this example, the function `calculateSum` takes two integer parameters `num1` and `num2`. It calculates the sum of these two numbers and stores the result in the `sum` variable. Finally, it returns the value of `sum` as the result of the function.

Calling a Function:

To call this function from another part of the program, you would simply use the function name followed by arguments enclosed in parentheses:

int result = calculateSum(10, 20);

In this case, the function is called with the arguments `10` and `20`, and the returned value (`30`) is stored in the `result` variable.

Types of Functions:

Now, let's look at some examples of different types of functions in C++:

1. Function with no parameters and no return value (void):

void sayHello()
{
    cout << "Hello, World!" << endl;
}

2. Function with parameters and a return value:

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

3. Function with parameters and no return value (void):

void printSum(int a, int b)
{
    int sum = a + b;

    cout << "The sum is: " << sum << endl;
}

4. Function with a return value but no parameters:

double getPi()
{
    return 3.14159;
}

Passing Variables by Reference:

In C++, passing variables to functions can be done by value or by reference. When a variable is passed by value, a copy of the variable is made and passed to the function. On the other hand, when a variable is passed by reference, the function receives a reference to the original variable, allowing the function to modify the variable directly. Passing variables by reference can be more efficient as it avoids making unnecessary copies of large objects and allows for in-place modification.

To pass variables by reference in C++, you use the ampersand (`&`) symbol in the function parameter declaration. Here's an example:

void increment(int& num)
{
    num++;
}

int main()
{

    int value = 5;

    increment(value);

    // The value is modified directly within the function
    // value is now 6

    return 0;
}

In this example, the `increment` function takes an `int` parameter `num` by reference. Inside the function, `num` can be modified, and any changes made to it will affect the original variable passed from `main()`. When `value` is passed to `increment()`, it is passed by reference, and the function increments the value by 1. After the function call, the value of `value` in `main()` is modified to 6.

NOTE: Passing variables by reference is particularly useful when you want to modify the value of a variable within a function and have those modifications reflected outside of the function. It can also be used to avoid unnecessary copying of large objects, which can improve performance and memory usage. (alert-success)

Function Proto-Type: 

In C++, a function prototype is a declaration of a function that provides the compiler with information about the function's name, return type, and parameter types. It serves as a forward declaration of the function, allowing you to use the function before its actual definition in the code.

The syntax of a function prototype is similar to that of a function declaration, with the main difference being that the function body is omitted. Here's the general structure of a function prototype:

return_type function_name(parameter1, parameter2, ...);

Let's look at an example to better understand function prototypes:

// Function prototype
int calculateSum(int num1, int num2);

int main()
{
    int result = calculateSum(10, 20);
    // Rest of the code

    return 0;
}

// Function definition
int calculateSum(int num1, int num2)
{
    int sum = num1 + num2;

    return sum;
}

In this example, the function `calculateSum` is declared before the `main` function using a function prototype. The prototype provides information to the compiler about the function's name, return type (`int`), and parameter types (`int num1` and `int num2`). With the prototype, the `calculateSum` function can be called in `main` even though its actual definition appears later in the code.

Function Overloading:

Function overloading is a feature in C++ that allows you to define multiple functions with the same name but different parameter lists. With function overloading, you can create functions that perform similar operations but with different argument types or different numbers of arguments. The compiler determines which function to call based on the arguments provided during the function call.

Here's an example to illustrate function overloading:

// Function with two integer parameters
int add(int num1, int num2)
{
    return num1 + num2;
}

// Function with two float parameters
float add(float num1, float num2)
{
    return num1 + num2;
}

// Function with three integer parameters
int add(int num1, int num2, int num3)
{
    return num1 + num2 + num3;
}

int main()
{
    int sum1 = add(5, 10);        // Calls the first add() function
    float sum2 = add(2.5, 3.7);   // Calls the second add() function
    int sum3 = add(1, 2, 3);     // Calls the third add() function

    return 0;
}

In this example, the `add` function is overloaded three times. The first `add` function takes two integer parameters, the second `add` function takes two float parameters, and the third `add` function takes three integer parameters. Each function performs addition but with different parameter types or numbers of parameters.

During the function calls in `main`, the compiler determines the appropriate function to call based on the arguments provided. The first call to `add(5, 10)` matches the first overloaded `add` function with two integer parameters. The second call to `add(2.5, 3.7)` matches the second overloaded `add` function with two float parameters. The third call to `add(1, 2, 3)` matches the third overloaded `add` function with three integer parameters.