Week 5: Building Reusable Code with Functions

Chapter 5: Functions - Modularizing Your Code

Defining Functions.

Functions are blocks of code designed to perform a specific task. They allow you to break down large programs into smaller, manageable, and reusable units. Using functions makes your code more organized, easier to understand, and simpler to debug and maintain.

Syntax

return_type function_name(parameter_type1 parameter_name1, parameter_type2 parameter_name2, ...) {
    // Code block (function body)
    statement1;
    statement2;
    // ...
    return value; // Optional: returns a value of 'return_type'
}

• `return_type`: The data type of the value the function will return (e.g., `int`, `double`, `void` if it returns nothing).
• `function_name`: A descriptive name for the function (following identifier rules).
• `parameter list`: Enclosed in parentheses `()`, specifies the type and name of input values the function accepts. Can be empty if the function takes no input.
• `{ ... }`: Curly braces enclose the function body, containing the code to be executed.
• `return value;`: Sends a value back to the part of the code that called the function. The type of `value` must match `return_type`. Functions with `void` return type don't need a `return` statement, or can use `return;` to exit early.

Example: A Simple Greeting Function

#include <iostream>
#include <string>

// Function definition
void greet(std::string name) {
    std::cout << "Hello, " << name << "!" << std::endl;
}

int main() {
    greet("Alice"); // Calling the function
    greet("Bob");   // Calling it again
    return 0;
}

Parameters and Arguments (Pass by Value).

Parameters are the variables listed in the function definition. Arguments are the actual values passed to the function when it is called.

Pass by Value

By default, C++ passes arguments by value. This means a copy of the argument's value is made and passed to the function parameter. Any modifications made to the parameter inside the function do not affect the original argument outside the function.

#include <iostream>

void tryToModify(int num) {
    num = 100; // Modifies the local copy (parameter 'num')
    std::cout << "Inside function, num = " << num << std::endl; // Outputs 100
}

int main() {
    int originalValue = 10;
    tryToModify(originalValue);
    std::cout << "Outside function, originalValue = " << originalValue << std::endl; // Outputs 10
    return 0;
}

We will cover other ways of passing arguments (like pass by reference and pass by pointer) in Week 7, which allow functions to modify the original arguments.

Default Arguments

You can provide default values for parameters in the function declaration (or definition if no separate declaration exists). If the caller omits an argument for that parameter, the default value is used. Default arguments must come after non-default arguments in the parameter list.

#include <iostream>

void showValues(int a, int b = 10, int c = 20) {
    std::cout << "a=" << a << ", b=" << b << ", c=" << c << std::endl;
}

int main() {
    showValues(1);          // Output: a=1, b=10, c=20
    showValues(1, 55);      // Output: a=1, b=55, c=20
    showValues(1, 55, 99); // Output: a=1, b=55, c=99
    return 0;
}

Function Overloading.

C++ allows you to define multiple functions with the same name but with different parameter lists (differing in the number or type of parameters). This is called function overloading.

The compiler determines which version of the function to call based on the arguments provided during the function call.

#include <iostream>
#include <string>

// Overloaded functions named 'printData'
void printData(int data) {
    std::cout << "Integer data: " << data << std::endl;
}

void printData(double data) {
    std::cout << "Double data: " << data << std::endl;
}

void printData(std::string data) {
    std::cout << "String data: " << data << std::endl;
}

int main() {
    printData(100);       // Calls the int version
    printData(3.14);     // Calls the double version
    printData("C++");    // Calls the string version
    return 0;
}

Note: Function overloading is based only on the parameter list, not the return type.