Overview

Functions are like building blocks. They encapsulate a set of instructions, allowing you to break down complex tasks into manageable, reusable units of code. Functions are fundamental to C++ and play a pivotal role in structuring your programs. In this chapter, we'll delve into the world of functions and explore their significance.

What is a Function ❓

A function is a self-contained block of code that performs a specific task or set of tasks. It's like a mini-program within your main program. Functions are used to modularize code, making it more organized, easier to read, and maintainable. They follow a set structure:

return_type function_name(parameters) {
    // Function body
    // Code to perform a task
    return result; // Optional return statement
}

• return_type: This specifies the data type of the value that the function will return after execution. If the function doesn't return anything, you use the void keyword.
• function_name: This is a unique identifier for your function. Choose a meaningful name that reflects the task it performs.
• parameters: These are optional inputs to the function. You can pass values to a function through parameters, allowing it to work with data provided from outside.
• function body: This is where you write the actual code that defines the function's behavior.
• return statement: If your function is supposed to return a value, use the return  statement to specify what value it should return. This part is optional for void functions.

Function Calls

In C++, a function call is the act of invoking a function to execute its code. When you call a function, the program transfers control to that function, and the statements within the function are executed. After the function completes its task, control returns to the point in the code from where the function was called.

return_type result_variable = function_name(arguments);

• return_type: The data type of the value that the function returns.
• result_variable: An optional variable to store the return value.
• function_name: The name of the function you want to call.
• arguments: The values or expressions passed as inputs to the function.

Example:

int result = add(1, 7); // Calling the add function

Here, the add function is called with the arguments 1 and 7, and the result is stored in the variable, result.

🅰️ Caller Function:

The function that initiates the function call is known as the caller function. In the example above caller function is the one that contains the add(1, 7); statement.

🅱️ Callee Function:

The function that is called by another function is referred to as the callee function. In the same example, the add function is the callee function because it is called by the caller function.

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

int main() {
	int result  = add (1, 7);
	//
	return 0;
}

In this code, main is the caller function because it calls the add function. add is the callee function as it performs the addition operation and returns the result.

1️⃣ Function Declaration:

It a generic term that refers to introducing a function to the compiler.

A function declaration tells the compiler about a function's existence, including its name, return type, and  optionally (parameters types). It serves as a contract or promise that the function will be defined later.

• Purpose: To inform the compiler that a function exists.
• Key Idea: A function declaration introduces a function to the compiler without providing its implementation.
• Parameter Types: May be omitted in older C standards (pre-C89),  but not in modern C.

Examples:

Without Parameter Types (Allowed in old C):

int add(); // Function declaration without parameter types

This tells the compiler there is a function named add that returns an int. However, the parameter types are not specified, so no type checking can be done on the arguments.

With Parameter Types (Modern C):

int add(int, int); // Function declaration with parameter types

This is also a declaration but now provides type information, allowing the compiler to check arguments passed to the function.

2️⃣ Function Prototype:

A special type of function declaration that includes parameters.

A function prototype is a specific type of function declaration that includes information about the types of parameters (and optionally their names). It enables the compiler to perform type checking on arguments during function calls.

• Purpose: Enables the compiler to perform type checking on arguments passed to the function.
• Key Idea: A function prototype provides full type information about the parameters.
• Parameter names are optional in prototypes but are often included for clarity.

Example:

int add(int a, int b); // Function prototype with parameter types and optional names

It tells the compiler:

• The same information as the declaration.
• Additionally, the parameter names (a and b), while optional, can clarify what each parameter represents.

Relationship Between Function Declaration and Function Prototype:

• Every function prototype is a function declaration, but not every function declaration is a prototype.
• In modern C (C89 and later), all function declarations are effectively prototypes because parameter types are required.

Forward Declaration:

It is not a distinct type of declaration. Instead, it is about the placement of a declaration or prototype in the code.

The forward declaration itself can use either a function declaration or a function prototype.

However in modern compilers it uses function prototypes, because modern compilers require parameters type for type checking.

• Definition: A forward declaration is the act or practice of declaring a function before its first use in the code.
• Purpose: Allows the compiler to process calls to a function before it encounters the function's definition.
• Key Idea: The declaration may use a prototype to describe the function.
  • It is required when a function is called before its definition.
  • A forward declaration typically uses a function prototype in modern C, but it can be a generic declaration in older standards.

Example:

Without Forward Declaration (Definition Comes First)

If the function is defined before use, no forward declaration is needed:

#include <stdio.h>

int add(int x, int y) { // Definition
    return x + y;
}

int main() {
    printf("Sum: %d\n", add(2, 3)); // Use
    return 0;
}

Here:

• The compiler encounters the function definition before the call and understands how add should be used.

With Forward Declaration:

When the function is used before its definition, a forward declaration is necessary:

#include <stdio.h>

int add(int, int); // Forward declaration (using a prototype)

int main() {
    printf("Sum: %d\n", add(2, 3)); // Use before definition
    return 0;
}

int add(int x, int y) { // Definition
    return x + y;
}

Here:

• The forward declaration introduces add to the compiler so it can process the call in main before seeing the actual definition.

Summary of Differences:

Main Function

The main function is a special function that serves as the starting point of the C/C++ program. When you run your program, the operating system calls the main function, and execution proceeds from there. This is why the main function is often referred to as the entry point of your program.

Syntax:

int main() {
	// Your program starts here
	// ....
	return 0; // Optional return value indicating success
}

• int: This indicates the data type of the value that main can return. By convention, a return value of 0 signifies a successful program execution, while non-zero values typically indicate an error.
• main: This is the name of the function, and it must be spelled exactly as “main”.
• () : The parentheses are empty.

The Execution Sequence

Here's how the execution of a C++ program typically works:

1. The operating system loads your compiled program into memory.
2. It locates the main function.
3. Execution begins at the first statement within main.
4. The program continues to execute line by line, following the flow of control based on conditional statements, loops, and function calls.
5. When the main function reaches its end or encounters a return statement, the program terminates, and control returns to the operating system.

Return Value of main

The main function can optionally return a value to the operating system. This return value serves as an indication of the program's exit status.

• A return value of 0 typically signifies that the program executed successfully without errors.
• Non-zero return values (usually positive integers) indicate that the program encountered an error or an exceptional condition. The specific values and their meanings can vary depending on your program's conventions.

Example:

int main() {
	// Your program logic here
	if (everything_is_fine) {
		return 0; // Program executed successfully
	} else {
		return 1; // Program encountered an error

Benefits of Using Functions

• Modularity: Functions allow you to break down a complex program into smaller, manageable parts.
• Reusability: Once you define a function, you can call it multiple times throughout the program.
• Readability: Well-named functions make your code more understandable and maintainable.
• Debugging: Functions simplify the process of identifying and fixing errors because you can focus on individual parts of your code.