Cpp Programming Function Objects And Lambdas Complete Guide

Function Objects (Functors)

What are Function Objects?

Function objects, also known as functors, are objects that can be called as if they were regular functions. They are instances of classes that implement the operator().

Example 1: Basic Function Object

Let's create a simple function object that adds two numbers.

#include <iostream>

// Define a class that overloads the operator()
class Add {
public:
    int operator()(int a, int b) {
        return a + b;
    }
};

int main() {
    // Create an instance of Add
    Add add;

    // Use the function object like a regular function
    int result = add(5, 3);
    std::cout << "5 + 3 = " << result << std::endl;

    return 0;
}

Explanation:

1. Class Definition:
   • We define a class Add with a public method operator() that takes two integers and returns their sum.
2. Creating an Instance:
   • We create an instance of the Add class named add.
3. Using the Function Object:
   • We call add(5, 3) as if it were a regular function, which invokes Add::operator().

Example 2: Stateful Function Objects

Function objects can maintain state between calls.

#include <iostream>

class Counter {
private:
    int count;
public:
    Counter() : count(0) {}

    int operator()() {
        return ++count;
    }
};

int main() {
    Counter counter;

    std::cout << counter() << std::endl;  // Output: 1
    std::cout << counter() << std::endl;  // Output: 2
    std::cout << counter() << std::endl;  // Output: 3

    return 0;
}

Explanation:

1. State Variable:
   • The Counter class has a private member variable count to maintain the state.
2. Incrementing the Count:
   • Every time the operator() is called, it increments the count and returns the new value.

Example 3: Using Function Objects with Standard Library Algorithms

Function objects are often used in conjunction with algorithms from the Standard Library.

#include <iostream>
#include <vector>
#include <algorithm>

// Functors for comparison
struct GreaterThan {
    int value;
    GreaterThan(int v) : value(v) {}

    bool operator()(int a) {
        return a > value;
    }
};

int main() {
    std::vector<int> numbers = {1, 3, 5, 7, 9};

    // Using find_if with a function object
    auto result = std::find_if(numbers.begin(), numbers.end(), GreaterThan(4));

    if (result != numbers.end()) {
        std::cout << "First number greater than 4 is: " << *result << std::endl;
    } else {
        std::cout << "No number greater than 4 found." << std::endl;
    }

    return 0;
}

Explanation:

1. Functor for Comparison:
   • The GreaterThan class takes a value and stores it. The operator() checks if a given number is greater than this value.
2. Using find_if:
   • We use std::find_if from the Standard Library, which applies the GreaterThan functor to each element of the vector until it finds an element that satisfies the condition (a > 4).

Lambdas

What are Lambdas?

Lambdas provide a convenient way to write simple, unnamed functions. They can capture variables from the surrounding scope and are often used for short snippets of code.

Example 1: Simple Lambda Expression

Here's a basic example of a lambda that adds two numbers.

#include <iostream>

int main() {
    // Define a lambda function
    auto add = [](int a, int b) -> int {
        return a + b;
    };

    // Use the lambda function
    int result = add(5, 3);
    std::cout << "5 + 3 = " << result << std::endl;

    return 0;
}

Explanation:

1. Lambda Syntax:
   • auto add = [](int a, int b) -> int { return a + b; };
   • [] is the capture list (empty in this case).
   • (int a, int b) are the parameters.
   • -> int specifies the return type (optional if it can be deduced).
   • { return a + b; } is the function body.
2. Using the Lambda:
   • We call add(5, 3) as if it were a regular function.

Example 2: Lambda with Capture List

Lambdas can capture variables from the enclosing scope.

#include <iostream>

int main() {
    int multiplier = 10;

    // Define a lambda that captures the multiplier variable by value
    auto multiply = [multiplier](int a) -> int {
        return a * multiplier;
    };

    // Use the lambda function
    int result = multiply(5);
    std::cout << "5 * " << multiplier << " = " << result << std::endl;

    return 0;
}

Explanation:

1. Capture by Value:
   • [multiplier] means the lambda captures multiplier by value.
2. Using the Lambda:
   • multiply(5) multiplies 5 by 10 (the captured value of multiplier).

Example 3: Mutable Lambda

For modifying captured variables, lambda can be marked mutable.

#include <iostream>

int main() {
    int number = 5;

    // Define a mutable lambda
    auto increment = [number]() mutable -> int {
        return ++number;
    };

    // Use the lambda function
    int result = increment();
    std::cout << "Incremented number: " << result << std::endl;

    // Note: The original captured variable 'number' is not modified
    std::cout << "Original number: " << number << std::endl;

    return 0;
}

Explanation:

1. Mutable Lambda:
   • [number] captures number by value.
   • mutable allows the lambda to modify its copy of number.
2. Using the Lambda:
   • increment() increments the copy of number, but the original number remains unchanged.

Example 4: Lambda with std::for_each

Lambdas are often used with algorithms from the Standard Library.

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // Use a lambda with std::for_each to print each number
    std::for_each(numbers.begin(), numbers.end(), [](int num) {
        std::cout << num << " ";
    });
    std::cout << std::endl;

    return 0;
}

Explanation:

1. Using std::for_each:
   • std::for_each applies the lambda to each element of the vector.
   • The lambda simply prints each number.

Conclusion

Function objects and lambdas are powerful tools in C++ that enhance the flexibility and readability of code. Function objects allow for stateful and reusable function-like classes, while lambdas provide a concise way to write inline functions. Both can be used effectively with the Standard Library algorithms to perform complex operations in a readable manner.