Functions

A function is a self-contained block of code that performs a specific task or set of tasks. Functions provide a way to organize and modularize code, making it more readable, maintainable, and reusable.

#include <iostream>

// Function to calculate the factorial of a number
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int num = 5;
    std::cout << "The factorial of " << num << " is: " << factorial(num) << std::endl;
    return 0;
}

Inline

inline keyword is used to suggest to the compiler that it should attempt to insert the code of a function directly into the calling code, rather than generating a function call. This can lead to performance improvements in certain situations by avoiding the overhead of a function call.

#include <iostream>

// Inline function definition
static inline int square(int x) {
    return x * x;
}

int main() {
    int num = 5;
    // Call to the inline function
    int result = square(num);
    std::cout << "Square of " << num << " is: " << result << std::endl;
    return 0;
}

Variadic

A variadic function is a function that can accept a variable number of arguments. The cstdarg header provides a set of macros and types to work with such functions.

#include <iostream>
#include <cstdarg>

// Variadic function to calculate the sum of integers
int sum(int count, ...) {
    int result = 0;

    // Initialize the va_list
    va_list args;

    // Start processing the arguments
    va_start(args, count);

    // Loop through the arguments and accumulate the sum
    for (int i = 0; i < count; ++i) {
        result += va_arg(args, int);
    }

    // Clean up the va_list
    va_end(args);

    return result;
}

int main() {
    // Call the variadic function with different numbers of arguments
    std::cout << "Sum: " << sum(3, 1, 2, 3) << std::endl;
    std::cout << "Sum: " << sum(5, 10, 20, 30, 40, 50) << std::endl;

    return 0;
}

Note that the sum function needs at least one fixed argument (count) to determine the number of variable arguments. The va_arg macro is used to retrieve each variable argument based on its type.

Lambda Expressions

Lambda expressions in C++ allow you to define anonymous functions or function objects (closures) directly within your code. Lambda expressions provide a concise way to create functions, especially for short-lived and local purposes.

#include <iostream>

int main() {
    // Lambda expression to add two numbers
    auto add = [](int a, int b) {
        return a + b;
    };

    // Using the lambda to add two numbers
    int result = add(3, 5);

    std::cout << "Result of adding 3 and 5: " << result << std::endl;

    // Lambda expression to multiply two numbers
    auto multiply = [](int x, int y) -> int {
        return x * y;
    };

    // Using the lambda to multiply two numbers
    result = multiply(4, 6);

    std::cout << "Result of multiplying 4 and 6: " << result << std::endl;

    // Lambda expression with no parameters
    auto sayHello = [] {
        std::cout << "Hello, Lambda!" << std::endl;
    };

    // Using the lambda with no parameters
    sayHello();

    return 0;
}

Code Challenge

Write a C++ program that defines a variadic function named calculateAverage to calculate the average of a variable number of arguments.