Functions in C++

What is a Function in C++?

A function is a block of code that performs a specific task. You can call a function multiple times within your program, reducing code duplication and increasing code reusability.

Why Use Functions?

• Code Reusability: Write once, use anywhere.
• Modularity: Break complex code into smaller, manageable blocks.
• Maintainability: Easier to update and debug.
• Readability: Code becomes more organized.

Anatomy of a Function

A function in C++ has four key components:

1. Return Type: The type of value the function returns (e.g., int, void).
2. Function Name: A unique identifier for the function.
3. Parameters (Optional): Inputs to the function.
4. Function Body: The block of code that performs the task.

Syntax:

return_type function_name(parameter_list) {
    // Function body (statements)
}

Example:

#include <iostream>
using namespace std;

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

int main() {
    int result = add(5, 3);  // Function call
    cout << "Sum: " << result << endl;
    return 0;
}

Output:

Sum: 8

Types of Functions

1. Built-in Functions: Provided by C++ libraries (e.g., cout, cin, sqrt()).
2. User-Defined Functions: Created by the programmer.

Function Declaration (Prototype)

A function must be declared before it is used. This can be done using a function prototype, which provides the function’s name, return type, and parameter list without the body.

Syntax:

return_type function_name(parameter_list);

Example:

#include <iostream>
using namespace std;

// Function Prototype
int multiply(int, int);

int main() {
    int result = multiply(4, 5);
    cout << "Product: " << result << endl;
    return 0;
}

// Function Definition
int multiply(int a, int b) {
    return a * b;
}

Output:

Product: 20

Function Definition

This is where you write the actual logic of the function.

Example:

// Function definition
int subtract(int a, int b) {
    return a - b;
}

Calling a Function

To use a function, you simply call it by its name followed by parentheses.

Example:

int main() {
    int result = subtract(10, 5);
    cout << "Difference: " << result << endl;
}

Output:

Difference: 5

Function Parameters

Functions can accept inputs in the form of parameters. There are two main types:

1. Pass by Value:

• A copy of the argument is passed to the function.
• Changes made within the function do not affect the original variable.

Example:

#include <iostream>
using namespace std;

void changeValue(int x) {
    x = 100; // Only a copy is modified
}

int main() {
    int num = 50;
    changeValue(num);
    cout << "Value of num: " << num << endl;
    return 0;
}

Output:

Value of num: 50

2. Pass by Reference:

• The address of the argument is passed to the function.
• Changes made in the function directly affect the original variable.

Syntax:

void changeValue(int &x) {
    x = 100;  // Original value is modified
}

Example:

#include <iostream>
using namespace std;

void changeValue(int &x) {
    x = 100; // Directly modifies the original variable
}

int main() {
    int num = 50;
    changeValue(num);
    cout << "Value of num: " << num << endl;
    return 0;
}

Output:

Value of num: 100

Default Arguments

Default arguments allow you to specify default values for parameters, which are used if no value is provided during the function call.

Syntax:

int multiply(int a, int b = 1) {
    return a * b;
}

Example:

#include <iostream>
using namespace std;

int multiply(int a, int b = 2) {
    return a * b;
}

int main() {
    cout << "Multiply (3, 4): " << multiply(3, 4) << endl;
    cout << "Multiply (5): " << multiply(5) << endl;
    return 0;
}

Output:

Multiply (3, 4): 12
Multiply (5): 10

Function Overloading

Function overloading allows you to create multiple functions with the same name but different parameter lists.

Rules for Function Overloading:

• Functions must differ in the type, number, or order of parameters.
• The return type does not matter for overloading.

Example:

#include <iostream>
using namespace std;

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

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

int main() {
    cout << "Sum (int): " << add(3, 4) << endl;
    cout << "Sum (double): " << add(3.5, 4.2) << endl;
    return 0;
}

Output:

Sum (int): 7
Sum (double): 7.7

Inline Functions

Inline functions are small functions defined with the inline keyword, which are expanded at the point of call rather than invoking a function call.

Syntax:

inline int square(int x) {
    return x * x;
}

Example:

#include <iostream>
using namespace std;

inline int square(int x) {
    return x * x;
}

int main() {
    cout << "Square of 5: " << square(5) << endl;
    return 0;
}

Output:

Square of 5: 25

When to Use Inline Functions:

• For small, frequently used functions.
• Avoid using inline for complex functions (loops, large code).

Recursion (Functions Calling Themselves)

Recursion is when a function calls itself.

Example:

#include <iostream>
using namespace std;

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

int main() {
    cout << "Factorial of 5: " << factorial(5) << endl;
    return 0;
}

Output:

Factorial of 5: 120

When to Use Recursion:

• Problems that can be divided into smaller, similar problems (e.g., Factorial, Fibonacci).
• When iterative solutions are complex.

Summary

In this tutorial, you learned:

• What functions are and their benefits.
• How to define, declare, and call functions.
• Different types of function parameters (pass by value, pass by reference).
• Advanced function concepts (default arguments, overloading, inline functions, recursion).