Functions in C++

1. Function Declaration and Definition

Function Declaration (Prototype)

Tells the compiler about the function's name, return type, and parameters:

return_type function_name(parameter_list);

Function Definition

Contains the actual body of the function:

return_type function_name(parameter_list) {
    // function body
    return value;  // if return_type is not void
}

Example

#include <iostream>
using namespace std;

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

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

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

2. Types of Functions

Functions with Return Value

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

Functions without Return Value (void)

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

Functions with Parameters

void greet(string name) {
    cout << "Hello, " << name << "!" << endl;
}

Functions without Parameters

int getRandomNumber() {
    return rand() % 100;
}

3. Parameter Passing Methods

Pass by Value

A copy of the value is passed to the function. Changes inside the function don't affect the original:

#include <iostream>
using namespace std;

void increment(int x) {
    x++;  // Changes local copy only
    cout << "Inside function: " << x << endl;
}

int main() {
    int num = 5;
    increment(num);
    cout << "In main: " << num << endl;  // Still 5
    return 0;
}

Pass by Reference

The actual variable is passed. Changes inside the function affect the original:

#include <iostream>
using namespace std;

void increment(int &x) {
    x++;  // Changes original variable
    cout << "Inside function: " << x << endl;
}

int main() {
    int num = 5;
    increment(num);
    cout << "In main: " << num << endl;  // Now 6
    return 0;
}

Pass by Pointer

Address of the variable is passed. Changes affect the original:

#include <iostream>
using namespace std;

void increment(int *x) {
    (*x)++;  // Changes original variable
    cout << "Inside function: " << *x << endl;
}

int main() {
    int num = 5;
    increment(&num);
    cout << "In main: " << num << endl;  // Now 6
    return 0;
}

4. Function Overloading

Multiple functions can have the same name but different parameters (different number or types):

#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 add(int a, int b, int c) {
    return a + b + c;
}

int main() {
    cout << add(5, 3) << endl;        // Calls int add(int, int)
    cout << add(5.5, 3.2) << endl;    // Calls double add(double, double)
    cout << add(1, 2, 3) << endl;     // Calls int add(int, int, int)
    return 0;
}

5. Default Arguments

Parameters can have default values. If not provided, default values are used:

#include <iostream>
using namespace std;

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

int main() {
    cout << multiply(5) << endl;        // 5 * 1 * 1 = 5
    cout << multiply(5, 2) << endl;    // 5 * 2 * 1 = 10
    cout << multiply(5, 2, 3) << endl; // 5 * 2 * 3 = 30
    return 0;
}

Note: Default arguments must be specified from right to left.

6. Inline Functions

Suggests the compiler to insert the function code at the call site to reduce function call overhead:

#include <iostream>
using namespace std;

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

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

Note: Inline is a request, not a command. The compiler may ignore it for large functions.

7. Recursive Functions

A function that calls itself is called recursive:

#include <iostream>
using namespace std;

// Factorial using recursion
int factorial(int n) {
    if (n <= 1) {
        return 1;  // Base case
    }
    return n * factorial(n - 1);  // Recursive call
}

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

8. Function Templates

Generic functions that work with different data types:

#include <iostream>
using namespace std;

template <typename T>
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    cout << maximum(5, 10) << endl;           // int
    cout << maximum(5.5, 3.2) << endl;        // double
    cout << maximum('a', 'z') << endl;         // char
    return 0;
}