Functions in C++

What is a Function?

A function is a block of code that performs a specific task. Think of a function as a mini-program within your main program. Functions help you organize your code into manageable pieces, making it easier to understand, maintain, and reuse.

Why Use Functions?

Code Reusability: Write once, use many times
Better Organization: Break down complex problems into smaller parts
Easier Maintenance: Fix or update in one place instead of multiple places
Easier Debugging: Test small parts of your program independently

Function Structure in C++

A function in C++ has the following structure:

returnType functionName(parameterList) {
    // function body
    // statements
    return value; // Optional, depends on the return type
}

Where:

returnType: The data type of the value the function returns (or void if it doesn’t return anything)
functionName: The name of the function (should describe what the function does)
parameterList: The inputs to the function (optional)
function body: The code that performs the task
return statement: Sends a value back to where the function was called (not needed for void functions)

Simple Function Example

#include <iostream>
using namespace std;

// Function declaration
int add(int a, int b);

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

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

Function Declaration vs Definition

Function Declaration (Prototype):
- Tells the compiler about the function’s name, return type, and parameters
- Ends with a semicolon
- Usually placed at the beginning of the program
```
int add(int a, int b);
```
Function Definition:
- Contains the actual code that runs when the function is called
- Includes the function body in curly braces
- Can be placed anywhere in the program (before or after it’s called)
```
int add(int a, int b) {
    return a + b;
}
```

Types of Functions in C++

Built-in Functions: Pre-defined functions in C++ libraries
- Example: sqrt(), pow(), abs(), etc.
User-defined Functions: Functions created by programmers
- Example: The add() function we created above

Function Parameters

Parameters are variables listed in the function declaration that act as placeholders for the values that will be passed to the function when it’s called.

Types of Parameters:

Formal Parameters: Variables in the function declaration

void greet(string name) { // name is a formal parameter
    cout << "Hello, " << name << endl;
}

Actual Parameters (Arguments): Values passed when calling the function
```
greet("John"); // "John" is an actual parameter
```

Parameter Passing Methods:

Pass by Value:

Creates a copy of the argument
Changes to the parameter inside the function do not affect the original variable

void increment(int num) {
    num = num + 1; // Only changes the local copy
}

int main() {
    int x = 10;
    increment(x);
    cout << x << endl; // Still prints 10
    return 0;
}

Pass by Reference:

Passes the memory address of the argument
Changes to the parameter affect the original variable
Uses the & symbol

void increment(int &num) {
    num = num + 1; // Changes the original variable
}

int main() {
    int x = 10;
    increment(x);
    cout << x << endl; // Prints 11
    return 0;
}

Pass by Address (Pointer):

Passes the memory address of the argument using pointers
Changes to the parameter affect the original variable
Uses the * symbol

void increment(int *num) {
    *num = *num + 1; // Changes the original variable
}

int main() {
    int x = 10;
    increment(&x);
    cout << x << endl; // Prints 11
    return 0;
}

Default Arguments

You can assign default values to function parameters, which are used when the function is called without those arguments.

void printMessage(string message = "Hello, World!") {
    cout << message << endl;
}

int main() {
    printMessage();           // Prints "Hello, World!"
    printMessage("Hi there"); // Prints "Hi there"
    return 0;
}

Rules for default arguments:

Default arguments must be at the end of the parameter list
Once you provide a default value for a parameter, all parameters to its right must also have default values

Return Statement

The return statement:

Sends a value back to where the function was called
Exits the function immediately (any code after the return statement won’t execute)

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

Void Functions

Functions that don’t return a value have a return type of void.

void printHello() {
    cout << "Hello, World!" << endl;
    // No return statement needed
}

Function Overloading

C++ allows multiple functions with the same name but different parameters. This is called function overloading and will be covered in detail in a separate note.

Scope of Variables in Functions

Local Variables: Declared inside a function and only accessible within that function

void myFunction() {
    int x = 10; // Local variable
    // x can only be used inside this function
}

Global Variables: Declared outside all functions and accessible throughout the program

int globalVar = 20; // Global variable

void myFunction() {
    // globalVar can be accessed here
    cout << globalVar << endl;
}

Recursive Functions

A recursive function is one that calls itself directly or indirectly.

int factorial(int n) {
    // Base case
    if (n == 0 || n == 1) {
        return 1;
    }
    // Recursive case
    else {
        return n * factorial(n - 1);
    }
}

Every recursive function must have:

A base case that stops the recursion
A recursive case that moves toward the base case

The main() Function

The main() function is special:

It’s the entry point of your program
Execution always starts at main()
It should return an integer (usually 0 for success)

int main() {
    // Your program starts here
    
    return 0; // Program executed successfully
}

Benefits of Using Functions

Modular Programming: Break down complex problems into smaller, manageable pieces
Code Reusability: Write once, use many times
Abstraction: Hide the complex implementation details
Testing: Test each function independently
Maintenance: Update or fix in one place

Best Practices for Functions

Each function should perform a single, well-defined task
Use meaningful function names that describe what the function does
Keep functions small and focused
Document your functions with comments
Validate input parameters when necessary
Be consistent with your naming conventions
Limit the number of parameters (ideally fewer than 5)

Summary

Functions are essential building blocks in C++ programming. They help organize your code, make it reusable, and break down complex problems into manageable parts. Understanding how to create and use functions effectively is a fundamental skill for any programmer.