Lambda Expressions in C++

# CHAPTER 26

Lambda Expressions #

1. Introduction #

2. Learning Objectives #

• Understand the syntax of a Lambda Expression.

• Use the Capture Clause [] to access external variables.

• Pass parameters () to a Lambda.

• Define trailing return types ->.

• Pass Lambdas to STL algorithms like std::sort.

3. Syntax of a Lambda #

Syntax: captureclause -> returntype { body };

#include <iostream>
using namespace std;

int main() {
    // A basic lambda that takes no parameters and captures nothing
    auto sayHello = []() {
        cout << "Hello from Lambda!" << endl;
    };
    
    // Call the lambda like a normal function
    sayHello();
    
    return 0;
}

4. Parameters and Return Types #

// Lambda with parameters
auto add = [](int a, int b) {
    return a + b; // Compiler deduces return type is int
};

cout << add(5, 10) << endl; // Prints 15

// Lambda with an explicit return type
auto divide = [](double a, double b) -> double {
    if (b == 0) return 0.0;
    return a / b;
};

5. The Capture Clause [] #

• [x] : Capture variable x by value (read-only copy).

• [&x] : Capture variable x by reference (can modify the original).

• [=] : Capture ALL external variables by value.

• [&] : Capture ALL external variables by reference.

int main() {
    int multiplier = 5;
    
    // Capture 'multiplier' by value
    auto multiply = [multiplier](int num) {
        return num * multiplier;
    };
    
    cout << multiply(10) << endl; // Prints 50
    
    int score = 0;
    // Capture 'score' by reference so we can modify it
    auto scorePoint = [&score]() {
        score++;
    };
    
    scorePoint();
    cout << "Score is: " << score << endl; // Prints 1
    
    return 0;
}

6. Lambdas with STL Algorithms #

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> v = {4, 1, 3, 5, 2};
    
    // Sort descending using a lambda
    sort(v.begin(), v.end(), [](int a, int b) {
        return a > b; // Custom rule: a comes before b if a is greater
    });
    
    // Output: 5 4 3 2 1
    for (int num : v) { cout << num << " "; }
    
    return 0;
}

7. Memory-Level Explanation #

8. Common Mistakes #

• Modifying captured-by-value variables: If you write [x]() { x++; }, the compiler throws an error because captured values are const (read-only) by default. You must either capture by reference [&x] or use the mutable keyword: [x]() mutable { x++; }.

• Dangling References: Capturing by reference [&] in a lambda that outlives the scope of the variables it captured will cause memory corruption (just like a dangling pointer).

9. Exercises #

1. 1. Write a lambda expression that takes an integer and returns true if it is even, and false otherwise.

1. 2. Create a vector of numbers. Use std::count_if with a lambda to count how many numbers in the vector are greater than 10.

10. MCQ Quiz with Answers #

Q10. Can you assign a lambda to an auto variable and call it later? a) Yes b) No Answer: a) Yes

11. Interview Questions #

• Q: Explain what the mutable keyword does in a Lambda expression.

• Q: Explain the hidden mechanics of a Lambda (how the compiler transforms it into a class/functor).

• Q: What is the risk of capturing variables by reference [&] in a lambda that is stored and executed later?

12. Summary #

13. Next Chapter Recommendation #