{"id":1971,"date":"2024-06-22T23:26:58","date_gmt":"2024-06-22T23:26:58","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1971"},"modified":"2024-06-22T23:27:12","modified_gmt":"2024-06-22T23:27:12","slug":"how-to-work-with-lambda-expressions-in-cpp","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/","title":{"rendered":"How to Work with Lambda Expressions in C++"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient way to create anonymous function objects at the point where they are needed. This tutorial will delve into the details of working with lambda expressions in C++, targeting non-beginner programmers who already have a solid understanding of the language but want to deepen their knowledge of this powerful feature.<\/p>\n\n\n\n

What Are Lambda Expressions?<\/h3>\n\n\n\n

A lambda expression in C++ is essentially a way to define an anonymous function, i.e., a function without a name. Lambda expressions can be used wherever function objects are required, such as in algorithms, callbacks, or in custom function templates. They allow you to write inline functions in a compact form, enhancing code readability and maintainability.<\/p>\n\n\n\n

Syntax of Lambda Expressions<\/h3>\n\n\n\n

The general syntax of a lambda expression is:<\/p>\n\n\n

[capture](parameters) -> return_type { body }<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    \n
  • capture<\/code>: Specifies which variables from the surrounding scope are to be captured and made available inside the lambda.<\/li>\n\n\n\n
  • parameters<\/code>: Specifies the parameters passed to the lambda, similar to regular functions.<\/li>\n\n\n\n
  • return_type<\/code>: Specifies the return type of the lambda. This is optional if the return type can be inferred.<\/li>\n\n\n\n
  • body<\/code>: The code that defines the behavior of the lambda.<\/li>\n<\/ul>\n\n\n\n
    Basic Example<\/h3>\n\n\n\n
    Let’s start with a simple example to illustrate the basic usage of a lambda expression:<\/p>\n\n\n
    #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    auto<\/span> add = [](int<\/span> a, int<\/span> b) -> int<\/span> {\n        return<\/span> a + b;\n    };\n\n    int<\/span> result = add(5<\/span>, 3<\/span>);\n    std<\/span>::cout<\/span> << \"Result: \"<\/span> << result << std<\/span>::endl<\/span>; \/\/ Output: Result: 8<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, we define a lambda expression add<\/code> that takes two integers and returns their sum. We then call this lambda with the arguments 5 and 3 and print the result.<\/p>\n\n\n\n
    Capturing Variables<\/h2>\n\n\n\n
    One of the key features of lambda expressions is the ability to capture variables from their enclosing scope. There are several ways to capture variables:<\/p>\n\n\n\n
    Capture by Value<\/h3>\n\n\n\n
    When you capture a variable by value, the lambda makes a copy of the variable. Changes to the variable inside the lambda do not affect the original variable outside the lambda.<\/p>\n\n\n
    #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    int<\/span> x = 10<\/span>;\n    auto<\/span> printX = [x]() {\n        std<\/span>::cout<\/span> << \"x: \"<\/span> << x << std<\/span>::endl<\/span>;\n    };\n\n    x = 20<\/span>;\n    printX(); \/\/ Output: x: 10<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    Capture by Reference<\/h3>\n\n\n\n
    When you capture a variable by reference, the lambda has access to the original variable. Changes to the variable inside the lambda affect the original variable.<\/p>\n\n\n
    #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    int<\/span> x = 10<\/span>;\n    auto<\/span> printX = [&x]() {\n        std<\/span>::cout<\/span> << \"x: \"<\/span> << x << std<\/span>::endl<\/span>;\n    };\n\n    x = 20<\/span>;\n    printX(); \/\/ Output: x: 20<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    Capture by Value and Reference<\/h3>\n\n\n\n
    You can capture multiple variables, some by value and some by reference.<\/p>\n\n\n
    #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    int<\/span> x = 10<\/span>;\n    int<\/span> y = 20<\/span>;\n    auto<\/span> printXY = [x, &y]() {\n        std<\/span>::cout<\/span> << \"x: \"<\/span> << x << \", y: \"<\/span> << y << std<\/span>::endl<\/span>;\n    };\n\n    x = 30<\/span>;\n    y = 40<\/span>;\n    printXY(); \/\/ Output: x: 10, y: 40<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
    Capture All Variables<\/h3>\n\n\n\n
    You can also capture all variables from the enclosing scope, either by value or by reference.<\/p>\n\n\n\n
      \n
    • Capture all by value:<\/li>\n<\/ul>\n\n\n
      #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    int<\/span> x = 10<\/span>;\n    int<\/span> y = 20<\/span>;\n    auto<\/span> printXY = [=]() {\n        std<\/span>::cout<\/span> << \"x: \"<\/span> << x << \", y: \"<\/span> << y << std<\/span>::endl<\/span>;\n    };\n\n    x = 30<\/span>;\n    y = 40<\/span>;\n    printXY(); \/\/ Output: x: 10, y: 20<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        \n
      • Capture all by reference:<\/li>\n<\/ul>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    int<\/span> x = 10<\/span>;\n    int<\/span> y = 20<\/span>;\n    auto<\/span> printXY = [&]() {\n        std<\/span>::cout<\/span> << \"x: \"<\/span> << x << \", y: \"<\/span> << y << std<\/span>::endl<\/span>;\n    };\n\n    x = 30<\/span>;\n    y = 40<\/span>;\n    printXY(); \/\/ Output: x: 30, y: 40<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Mixed Capture Modes<\/h3>\n\n\n\n
        You can mix capturing all variables by reference while capturing specific variables by value.<\/p>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    int<\/span> x = 10<\/span>;\n    int<\/span> y = 20<\/span>;\n    auto<\/span> printXY = [=, &y]() {\n        std<\/span>::cout<\/span> << \"x: \"<\/span> << x << \", y: \"<\/span> << y << std<\/span>::endl<\/span>;\n    };\n\n    x = 30<\/span>;\n    y = 40<\/span>;\n    printXY(); \/\/ Output: x: 10, y: 40<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Lambda Expressions with STL Algorithms<\/h2>\n\n\n\n
        One of the most powerful uses of lambda expressions is in conjunction with the Standard Template Library (STL) algorithms. Lambda expressions can be used as predicates or function objects in algorithms like std::sort<\/code>, std::for_each<\/code>, std::find_if<\/code>, etc.<\/p>\n\n\n\n
        Example: Using Lambda with std::sort<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::vector<\/span><int<\/span>> numbers = {5<\/span>, 2<\/span>, 8<\/span>, 1<\/span>, 3<\/span>};\n\n    std<\/span>::sort(numbers.begin(), numbers.end(), [](int<\/span> a, int<\/span> b) {\n        return<\/span> a < b;\n    });\n\n    for<\/span> (int<\/span> n : numbers) {\n        std<\/span>::cout<\/span> << n << \" \"<\/span>;\n    }\n    std<\/span>::cout<\/span> << std<\/span>::endl<\/span>; \/\/ Output: 1 2 3 5 8<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Example: Using Lambda with std::for_each<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::vector<\/span><int<\/span>> numbers = {5<\/span>, 2<\/span>, 8<\/span>, 1<\/span>, 3<\/span>};\n\n    std<\/span>::for_each(numbers.begin(), numbers.end(), [](int<\/span> n) {\n        std<\/span>::cout<\/span> << n << \" \"<\/span>;\n    });\n    std<\/span>::cout<\/span> << std<\/span>::endl<\/span>; \/\/ Output: 5 2 8 1 3<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Example: Using Lambda with std::find_if<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::vector<\/span><int<\/span>> numbers = {5<\/span>, 2<\/span>, 8<\/span>, 1<\/span>, 3<\/span>};\n\n    auto<\/span> it = std<\/span>::find_if(numbers.begin(), numbers.end(), [](int<\/span> n) {\n        return<\/span> n > 3<\/span>;\n    });\n\n    if<\/span> (it != numbers.end()) {\n        std<\/span>::cout<\/span> << \"Found a number greater than 3: \"<\/span> << *it << std<\/span>::endl<\/span>; \/\/ Output: Found a number greater than 3: 5<\/span>\n    } else<\/span> {\n        std<\/span>::cout<\/span> << \"No number greater than 3 found\"<\/span> << std<\/span>::endl<\/span>;\n    }\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Generic Lambdas<\/h2>\n\n\n\n
        Starting from C++14, lambda expressions can be generic, which means they can accept parameters of any type without explicitly specifying the types. This is achieved using the auto<\/code> keyword.<\/p>\n\n\n\n
        Example: Generic Lambda<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    auto<\/span> print = [](auto<\/span> value) {\n        std<\/span>::cout<\/span> << value << std<\/span>::endl<\/span>;\n    };\n\n    print(10<\/span>);        \/\/ Output: 10<\/span>\n    print(3.14<\/span>);      \/\/ Output: 3.14<\/span>\n    print(\"Hello\"<\/span>);   \/\/ Output: Hello<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Example: Generic Lambda with Multiple Parameters<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    auto<\/span> add = [](auto<\/span> a, auto<\/span> b) {\n        return<\/span> a + b;\n    };\n\n    std<\/span>::cout<\/span> << add(5<\/span>, 3<\/span>) << std<\/span>::endl<\/span>;       \/\/ Output: 8<\/span>\n    std<\/span>::cout<\/span> << add(2.5<\/span>, 1.5<\/span>) << std<\/span>::endl<\/span>;   \/\/ Output: 4<\/span>\n    std<\/span>::cout<\/span> << add(std<\/span>::string<\/span>(\"Hello \"<\/span>), std<\/span>::string<\/span>(\"World\"<\/span>)) << std<\/span>::endl<\/span>; \/\/ Output: Hello World<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Stateful Lambdas<\/h2>\n\n\n\n
        Lambdas can also maintain state across multiple calls by using the mutable<\/code> keyword. By default, captured variables are treated as const<\/code> within the lambda body. To modify the captured variables, the lambda must be marked as mutable<\/code>.<\/p>\n\n\n\n
        Example: Mutable Lambda<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    int<\/span> counter = 0<\/span>;\n\n    auto<\/span> increment = [counter]() mutable<\/span> {\n        return<\/span> ++counter;\n    };\n\n    std<\/span>::cout<\/span> << increment() << std<\/span>::endl<\/span>; \/\/ Output: 1<\/span>\n    std<\/span>::cout<\/span> << increment() << std<\/span>::endl<\/span>; \/\/ Output: 2<\/span>\n    std<\/span>::cout<\/span> << increment() << std<\/span>::endl<\/span>; \/\/ Output: 3<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        In this example, the counter<\/code> variable is captured by value, but since the lambda is marked as mutable<\/code>, it can modify the captured variable.<\/p>\n\n\n\n
        Lambda Expressions in Classes and Structs<\/h2>\n\n\n\n
        Lambdas can be used inside classes and structs, allowing you to define small helper functions in a concise way.<\/p>\n\n\n\n
        Example: Lambda in a Class<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nclass<\/span> NumberCollection<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> addNumber<\/span>(int<\/span> number)<\/span> <\/span>{\n        numbers.push_back(number);\n    }\n\n    void<\/span> printNumbers<\/span>()<\/span> const<\/span> <\/span>{\n        std<\/span>::for_each(numbers.begin(), numbers.end(), [](int<\/span> n) {\n            std<\/span>::cout<\/span> << n << \" \"<\/span>;\n        });\n        std<\/span>::cout<\/span> << std<\/span>::endl<\/span>;\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><int<\/span>> numbers;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    NumberCollection collection;\n    collection.addNumber(1<\/span>);\n    collection.addNumber(2<\/span>);\n    collection.addNumber(3<\/span>);\n\n    collection.printNumbers(); \/\/ Output: 1 2 3<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Capturing this Pointer<\/h2>\n\n\n\n
        When a lambda is defined inside a member function, you can capture the this<\/code> pointer to access members of the class.<\/p>\n\n\n\n
        Example: Capturing this Pointer<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nclass<\/span> NumberCollection<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> addNumber<\/span>(int<\/span> number)<\/span> <\/span>{\n        numbers.push_back(number);\n    }\n\n    void<\/span> printNumbers<\/span>()<\/span> const<\/span> <\/span>{\n        std<\/span>::for_each(numbers.begin(), numbers.end(), [this<\/span>](int<\/span> n) {\n            std<\/span>::cout<\/span> << n * multiplier << \" \"<\/span>;\n        });\n        std<\/span>::cout<\/span> << std<\/span>::endl<\/span>;\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><int<\/span>> numbers;\n    int<\/span> multiplier = 2<\/span>;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    NumberCollection collection;\n    collection.addNumber(1<\/span>);\n    collection.addNumber(2<\/span>);\n    collection.addNumber(3<\/span>);\n\n    collection.printNumbers(); \/\/ Output: 2 4 6<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        In this example, the lambda captures the this<\/code> pointer to access the multiplier<\/code> member of the NumberCollection<\/code> class.<\/p>\n\n\n\n
        Advanced Lambda Features<\/h2>\n\n\n\n
        Recursive Lambdas<\/h3>\n\n\n\n
        Lambdas can also be recursive, although this requires some workarounds because lambdas do not have a name to refer to themselves. One common approach is to use a std::function<\/code> to enable recursion.<\/p>\n\n\n\n
        Example: Recursive Lambda<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <functional><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::function<int<\/span>(int<\/span>)> factorial = [&](int<\/span> n) {\n        if<\/span> (n <= 1<\/span>) return<\/span> 1<\/span>;\n        else<\/span> return<\/span> n * factorial(n - 1<\/span>);\n    };\n\n    std<\/span>::cout<\/span> << \"Factorial of 5: \"<\/span> << factorial(5<\/span>) << std<\/span>::endl<\/span>; \/\/ Output: Factorial of 5: 120<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Lambdas with Default Arguments<\/h3>\n\n\n\n
        Lambdas can have default arguments just like regular functions.<\/p>\n\n\n\n
        Example: Lambda with Default Arguments<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    auto<\/span> greet = [](std<\/span>::string<\/span> name = \"World\"<\/span>) {\n        std<\/span>::cout<\/span> << \"Hello, \"<\/span> << name << \"!\"<\/span> << std<\/span>::endl<\/span>;\n    };\n\n    greet();            \/\/ Output: Hello, World!<\/span>\n    greet(\"Alice\"<\/span>);     \/\/ Output: Hello, Alice!<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Lambdas as Template Parameters<\/h3>\n\n\n\n
        Lambdas can be passed as template parameters, allowing you to write highly flexible and reusable code.<\/p>\n\n\n\n
        Example: Lambda as Template Parameter<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\ntemplate<\/span> <typename<\/span> Func>\nvoid<\/span> applyToVector<\/span>(std<\/span>::vector<\/span><int<\/span>>& vec, Func func)<\/span> <\/span>{\n    std<\/span>::for_each(vec.begin(), vec.end(), func);\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::vector<\/span><int<\/span>> numbers = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n\n    applyToVector(numbers, [](int<\/span>& n) {\n        n *= 2<\/span>;\n    });\n\n    for<\/span> (int<\/span> n : numbers) {\n        std<\/span>::cout<\/span> << n << \" \"<\/span>;\n    }\n    std<\/span>::cout<\/span> << std<\/span>::endl<\/span>; \/\/ Output: 2 4 6 8 10<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        In this example, the applyToVector<\/code> function template takes a lambda as a parameter and applies it to each element in the vector.<\/p>\n\n\n\n
        Practical Use Cases for Lambda Expressions<\/h2>\n\n\n\n
        Sorting Custom Objects<\/h3>\n\n\n\n
        Lambdas are particularly useful when sorting collections of custom objects.<\/p>\n\n\n\n
        Example: Sorting Custom Objects<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nclass<\/span> Person<\/span> {<\/span>\npublic<\/span>:\n    Person(std<\/span>::string<\/span> name, int<\/span> age) : name(name), age(age) {}\n\n    std<\/span>::string<\/span> getName<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> name; }\n    int<\/span> getAge<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> age; }\n\nprivate<\/span>:\n    std<\/span>::string<\/span> name;\n    int<\/span> age;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::vector<\/span><Person> people = {\n        Person(\"Alice\"<\/span>, 30<\/span>),\n        Person(\"Bob\"<\/span>, 25<\/span>),\n        Person(\"Charlie\"<\/span>, 35<\/span>)\n    };\n\n    std<\/span>::sort(people.begin(), people.end(), [](const<\/span> Person& a, const<\/span> Person& b) {\n        return<\/span> a.getAge() < b.getAge();\n    });\n\n    for<\/span> (const<\/span> Person& person : people) {\n        std<\/span>::cout<\/span> << person.getName() << \": \"<\/span> << person.getAge() << std<\/span>::endl<\/span>;\n    }\n    \/\/ Output:<\/span>\n    \/\/ Bob: 25<\/span>\n    \/\/ Alice: 30<\/span>\n    \/\/ Charlie: 35<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Event Handling and Callbacks<\/h3>\n\n\n\n
        Lambdas are also commonly used for event handling and callbacks, especially in GUI programming.<\/p>\n\n\n\n
        Example: Using Lambda for Callbacks<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <functional><\/span><\/span>\n\nvoid<\/span> registerCallback<\/span>(std<\/span>::function<void<\/span>(int<\/span>)> callback)<\/span> <\/span>{\n    callback(42<\/span>);\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    registerCallback([](int<\/span> value) {\n        std<\/span>::cout<\/span> << \"Callback received value: \"<\/span> << value << std<\/span>::endl<\/span>;\n    });\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Functional Programming<\/h3>\n\n\n\n
        Lambda expressions facilitate functional programming techniques in C++, such as higher-order functions and composition.<\/p>\n\n\n\n
        Example: Higher-Order Functions<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\nstd<\/span>::function<int<\/span>(int<\/span>)<\/span>> makeMultiplier<\/span>(int<\/span> factor)<\/span> <\/span>{\n    return<\/span> [factor](int<\/span> value) {\n        return<\/span> value * factor;\n    };\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    auto<\/span> doubleValue = makeMultiplier(2<\/span>);\n    auto<\/span> tripleValue = makeMultiplier(3<\/span>);\n\n    std<\/span>::cout<\/span> << \"Double of 5: \"<\/span> << doubleValue(5<\/span>) << std<\/span>::endl<\/span>; \/\/ Output: Double of 5: 10<\/span>\n    std<\/span>::cout<\/span> << \"Triple of 5: \"<\/span> << tripleValue(5<\/span>) << std<\/span>::endl<\/span>; \/\/ Output: Triple of 5: 15<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Example: Function Composition<\/h3>\n\n\n
        #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <functional><\/span><\/span>\n\nauto<\/span> compose<\/span>(std<\/span>::function<int<\/span>(int<\/span>)> f, std<\/span>::function<int<\/span>(int<\/span>)> g)<\/span> <\/span>{\n    return<\/span> [f, g](int<\/span> x) {\n        return<\/span> f(g(x));\n    };\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    auto<\/span> addOne = [](int<\/span> x) {\n        return<\/span> x + 1<\/span>;\n    };\n\n    auto<\/span> doubleValue = [](int<\/span> x) {\n        return<\/span> x * 2<\/span>;\n    };\n\n    auto<\/span> addOneThenDouble = compose(doubleValue, addOne);\n\n    std<\/span>::cout<\/span> << \"Result: \"<\/span> << addOneThenDouble(5<\/span>) << std<\/span>::endl<\/span>; \/\/ Output: Result: 12<\/span>\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
        Conclusion<\/h2>\n\n\n\n
        Lambda expressions are a powerful feature in C++ that enhance the language’s expressiveness and flexibility. They provide a concise way to define anonymous functions and can be used in various scenarios, such as STL algorithms, event handling, and functional programming. By understanding how to work with lambda expressions, you can write more readable, maintainable, and efficient C++ code.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Introduction Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient way to create anonymous function objects at the point where they are needed. This tutorial will delve into the details of working with lambda expressions in C++, targeting non-beginner programmers who already […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9,4],"tags":[],"class_list":["post-1971","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nHow to Work with Lambda Expressions in C++<\/title>\n<meta name=\"description\" content=\"Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Work with Lambda Expressions in C++\" \/>\n<meta property=\"og:description\" content=\"Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-06-22T23:26:58+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-06-22T23:27:12+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"4 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"How to Work with Lambda Expressions in C++\",\"datePublished\":\"2024-06-22T23:26:58+00:00\",\"dateModified\":\"2024-06-22T23:27:12+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/\"},\"wordCount\":866,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/\",\"name\":\"How to Work with Lambda Expressions in C++\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-06-22T23:26:58+00:00\",\"dateModified\":\"2024-06-22T23:27:12+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-lambda-expressions-in-cpp\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"How to Work with Lambda Expressions in C++\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Work with Lambda Expressions in C++","description":"Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/","og_locale":"en_US","og_type":"article","og_title":"How to Work with Lambda Expressions in C++","og_description":"Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient","og_url":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/","article_published_time":"2024-06-22T23:26:58+00:00","article_modified_time":"2024-06-22T23:27:12+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"4 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"How to Work with Lambda Expressions in C++","datePublished":"2024-06-22T23:26:58+00:00","dateModified":"2024-06-22T23:27:12+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/"},"wordCount":866,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/","url":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/","name":"How to Work with Lambda Expressions in C++","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-06-22T23:26:58+00:00","dateModified":"2024-06-22T23:27:12+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Lambda expressions, introduced in C++11, have revolutionized the way we write and use functions in C++. They provide a concise and convenient","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-lambda-expressions-in-cpp\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"How to Work with Lambda Expressions in C++"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1971","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1971"}],"version-history":[{"count":1,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1971\/revisions"}],"predecessor-version":[{"id":1972,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1971\/revisions\/1972"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1971"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1971"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1971"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}