Microsoft official documentation | Lambda expressions in C++ | Microsoft Learn<\/a>.<\/p>\n<\/blockquote>\n\n\n\nTable of contents<\/h2>\n\n\n\n
Basics<\/strong><\/p>\n\n\n\n\n- 1. Lambda Basic Syntax<\/li>\n\n\n\n
- 2. How to use Lambda expressions<\/li>\n\n\n\n
- 3. Detailed discussion of capture lists<\/li>\n\n\n\n
- 4. mutable keyword<\/li>\n\n\n\n
- 5. Lambda return value deduction<\/li>\n\n\n\n
- 6. Nested Lambda<\/li>\n\n\n\n
- 7. Lambda, std:function and delegates<\/li>\n\n\n\n
- 8. Lambda in asynchronous and concurrent programming<\/li>\n\n\n\n
- 9. Generic Lambda (C++14)
- Lambda Scope<\/li><\/ol>\n
\n- practice<\/li>\n<\/ol>\n<\/li>\n<\/ul>\n\n\n\n
Intermediate<\/strong><\/p>\n\n\n\n\n- 1. Lambda's underlying implementation<\/li>\n\n\n\n
- 2. Lambda type, decltype and conditional compilation<\/li>\n\n\n\n
- 3. Lambda\u2019s evolution in the new standard<\/li>\n\n\n\n
- 4. State-preserving Lambda<\/li>\n\n\n\n
- 5. Optimization and Lambda<\/li>\n\n\n\n
- 6. Integration with other programming paradigms<\/li>\n\n\n\n
- 7. Lambda and Exception Handling<\/li>\n<\/ul>\n\n\n\n
Advanced<\/strong><\/p>\n\n\n\n\n- 1. Lambda and noexcept<\/li>\n\n\n\n
- 2. Template parameters in Lambda (C++20 feature)<\/li>\n\n\n\n
- 3. Lambda Reflection<\/li>\n\n\n\n
- 4. Cross-platform and ABI issues<\/li>\n<\/ul>\n\n\n\n
Basics<\/h2>\n\n\n\n1. Lambda Basic Syntax<\/h3>\n\n\n\n
Lambda basically looks like this:<\/p>\n\n\n\n
[ capture_clause ] ( parameters ) -> return_type { \/\/ function_body }<\/code><\/pre>\n\n\n\n\n- Capture clause (capture_clause<\/strong>) determines which variables in the outer scope will be captured by this lambda and how they will be captured (by value, by reference, or not captured). We discuss capture clauses in detail in the next chapter.<\/li>\n\n\n\n
- Parameter list (parameters<\/strong>) and the function body (function_body<\/strong>) is the same as a normal function, there is no difference.<\/li>\n\n\n\n
- Return Type (return_type<\/strong>) is slightly different. If the function body contains multiple statements and needs to return a value, the return type must be explicitly specified, unless all return statements return the same type, in which case the return type can be inferred automatically.<\/li>\n<\/ul>\n\n\n\n
2. How to use Lambda expressions<\/h3>\n\n\n\n
Syntax example:<\/p>\n\n\n\n
\/\/ \u4e00\u4e2a\u4e0d\u6355\u83b7\u4efb\u4f55\u5916\u90e8\u53d8\u91cf\u3001\u4e0d\u63a5\u53d7\u53c2\u6570\u3001\u6ca1\u6709\u8fd4\u56de\u503c\u7684lambda\nauto greet = [] { std::cout << \"Hello, World!\" << std::endl; };\n\n\/\/ \u4e00\u4e2a\u901a\u8fc7\u5f15\u7528\u6355\u83b7\u5916\u90e8\u53d8\u91cf\u3001\u63a5\u53d7\u4e00\u4e2aint\u53c2\u6570\u3001\u8fd4\u56deint\u7c7b\u578b\u7684lambda\nint x = 42;\nauto add_to_x = [&x](int y) -> int { return x + y; };\n\n\/\/ \u4e00\u4e2a\u901a\u8fc7\u503c\u6355\u83b7\u6240\u6709\u5916\u90e8\u53d8\u91cf\u3001\u63a5\u53d7\u4e24\u4e2a\u53c2\u6570\u3001\u8fd4\u56de\u7c7b\u578b\u88ab\u81ea\u52a8\u63a8\u65ad\u7684lambda\nint a = 1, b = 2;\nauto sum = [=](int x, int y) { return a + b + x + y; };\n\n\/\/ \u4f7f\u7528\u521d\u59cb\u5316\u6355\u83b7\u521b\u5efa\u65b0\u53d8\u91cf\u7684lambda\uff08C++14\u7279\u6027\uff09\nauto multiply = [product = a * b](int scalar) { return product * scalar; };<\/code><\/pre>\n\n\n\nPractical example:<\/p>\n\n\n\n
\n- As a sorting criterion<\/li>\n<\/ol>\n\n\n\n
\/\/ \u4f5c\u4e3a\u6392\u5e8f\u51c6\u5219\n#include <algorithm>\n#include <vector>\n#include <iostream>\n\nint main() {\n std::vector<int> v{4, 1, 3, 5, 2};\n std::sort(v.begin(), v.end(), [](int a, int b) {\n return a < b; \/\/ \u5347\u5e8f\u6392\u5217\n });\n\n for (int i : v) {\n std::cout << i << ' ';\n }\n \/\/ \u8f93\u51fa\uff1a1 2 3 4 5\n}<\/code><\/pre>\n\n\n\n\n- For forEach operation<\/li>\n<\/ol>\n\n\n\n
#include <vector>\n#include <iostream>\n#include <algorithm>\n\nint main() {\n std::vector<int> v{1, 2, 3, 4, 5};\n std::for_each(v.begin(), v.end(), [](int i) {\n std::cout << i * i << ' '; \/\/ \u6253\u5370\u6bcf\u4e2a\u6570\u5b57\u7684\u5e73\u65b9\n });\n \/\/ \u8f93\u51fa\uff1a1 4 9 16 25\n}<\/code><\/pre>\n\n\n\n\n- For cumulative functions<\/li>\n<\/ol>\n\n\n\n
#include <iostream>\n#include <vector>\n#include <numeric>\n\nint main() {\n std::vector<int> v{1, 2, 3, 4, 5};\n int sum = std::accumulate(v.begin(), v.end(), 0, [](int a, int b) {\n return a + b; \/\/ \u6c42\u548c\n });\n\n std::cout << sum << std::endl; \/\/ \u8f93\u51fa\uff1a15\n}<\/code><\/pre>\n\n\n\n\n- For thread constructor<\/li>\n<\/ol>\n\n\n\n
#include <thread>\n#include <iostream>\n\nint main() {\n int x = 10;\n std::thread t([x]() {\n std::cout << \"Value in thread: \" << x << std::endl;\n });\n t.join(); \/\/ \u8f93\u51fa\uff1aValue in thread: 10\n \/\/ \u6ce8\u610f\uff1a\u7ebf\u7a0b\u4e2d\u4f7f\u7528\u7684x\u662f\u5728\u521b\u5efa\u7ebf\u7a0b\u65f6\u6309\u503c\u6355\u83b7\u7684\n}<\/code><\/pre>\n\n\n\n3. Detailed discussion of the capture list<\/h3>\n\n\n\n
The capture list is optional. It specifies the external variables that can be accessed from within the lambda expression. Referenced external variables can be modified from within the lambda expression, but external variables captured by value cannot be modified, that is, variables prefixed with an ampersand (&) are accessed by reference, and variables without the prefix are accessed by value.<\/p>\n\n\n\n
\n- Do not capture any external variables<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp []{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda does not capture any variables from the outer scope.<\/p>\n\n\n\n
\n- By default, all external variables are captured (by reference)<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp [&]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda captures all variables in the outer scope and captures them by reference. If the captured variables are destroyed or out of scope when the lambda is called, undefined behavior occurs.<\/p>\n\n\n\n
\n- By default, all external variables are captured (by value)<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp[=]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda captures all outer scope variables by value, which means it uses a copy of the variables.<\/p>\n\n\n\n
\n- Explicitly capture specific variables (by value)<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp [x]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda captures the outer variable x by value.<\/p>\n\n\n\n
\n- Explicitly capture specific variables (by reference)<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp [&x]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda captures the outer variable x by reference.<\/p>\n\n\n\n
\n- Mixed capture (by value and by reference)<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp [x, &y]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda captures the variable x by value and the variable y by reference.<\/p>\n\n\n\n
\n- By default, variables are captured by value, but some variables are captured by reference.<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp [=, &x, &y]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda captures all outer variables by value by default, but captures variables x and y by reference.<\/p>\n\n\n\n
\n- By default, variables are captured by reference, but some are captured by value.<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp [&, x, y]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis lambda captures all outer variables by reference by default, but captures variables x and y by value.<\/p>\n\n\n\n
\n- Capturing the this pointer<\/strong>:<\/li>\n<\/ol>\n\n\n\n
cpp [this]{ \/\u2026<\/em>\/ }<\/p>\n\n\n\nThis allows the lambda expression to capture the this pointer of the class member function, thus giving access to the class's member variables and functions.<\/p>\n\n\n\n
\n- Capture with initializer expression (since C++14) \u2013 Generic lambda capture<\/strong>:cpp [x = 42]{ \/\u2026<\/em>\/ } creates an anonymous variable x inside the lambda, which can be used in the lambda function body. This is quite useful, for example, you can directly transfer std::unique_ptr with move semantics, which is discussed in detail in the "reference" below.<\/li>\n\n\n\n
- Capturing the asterisk this (since C++17)<\/strong>:cpp [this]{ \/<\/em>\u2026*\/ } This lambda captures the current object (the instance of its class) by value. This avoids the risk of the this pointer becoming a dangling pointer during the lambda's lifetime. Before C++17, you could get this by reference, but this had a potential memory risk, that is, if the lifetime of this ended, it would cause a memory leak. Using the asterisk this is equivalent to making a deep copy of the current object.<\/li>\n<\/ol>\n\n\n\n
\nstd::unique_ptr is a smart pointer with exclusive ownership. Its original design is to ensure that only one entity can own the object at a time. Therefore, std::unique_ptr cannot be copied, but can only be moved. If you want to capture by value, the compiler will report an error. If you capture by reference, the compiler will not report an error. But there are potential problems. I can think of three:<\/p>\n<\/blockquote>\n\n\n\n
\n- The life of std::unique_ptr ends before lambda. In this case, accessing this destroyed std::unique_ptr from within lambda will cause the program to crash.<\/li>\n\n\n\n
- If std::unique_ptr is moved after capture, the reference in the lambda is null, causing the program to crash.<\/li>\n\n\n\n
- In a multi-threaded environment, the above two problems will occur more frequently. To avoid these problems, you can consider value capture, that is, explicitly use std::move to transfer ownership. In a multi-threaded environment, lock.<\/li>\n<\/ol>\n\n\n\n
Code example:<\/p>\n\n\n\n
\n- Using Lambda as callback function \u2013 This example also involves function()<\/li>\n<\/ol>\n\n\n\n
#include <iostream>\n#include <functional>\n\n\/\/ \u5047\u8bbe\u6709\u4e00\u4e2a\u51fd\u6570\uff0c\u5b83\u5728\u67d0\u4e2a\u64cd\u4f5c\u5b8c\u6210\u540e\u8c03\u7528\u56de\u8c03\u51fd\u6570\nvoid performOperationAsync(std::function<void(int)> callback) {\n \/\/ \u5f02\u6b65\u64cd\u4f5c...\n int result = 42; \/\/ \u5047\u8bbe\u8fd9\u662f\u5f02\u6b65\u64cd\u4f5c\u7684\u7ed3\u679c\n callback(result); \/\/ \u8c03\u7528\u56de\u8c03\u51fd\u6570\n}\n\nint main() {\n int capture = 100;\n performOperationAsync([capture](int result) {\n std::cout << \"Async operation result: \" << result\n << \" with captured value: \" << capture << std::endl;\n });\n}<\/code><\/pre>\n\n\n\n\n- Used with smart pointers \u2013 This example also involves the mutable keyword<\/li>\n<\/ol>\n\n\n\n
#include <iostream>\n#include <memory>\n\nvoid processResource(std::unique_ptr<int> ptr) {\n \/\/ \u505a\u4e00\u4e9b\u5904\u7406\n std::cout << \"Processing resource with value \" << *ptr << std::endl;\n}\n\nint main() {\n auto ptr = std::make_unique<int>(10);\n\n \/\/ \u4f7f\u7528Lambda\u5ef6\u8fdf\u8d44\u6e90\u5904\u7406\n auto deferredProcess = [p = std::move(ptr)]() {\n processResource(std::move(p));\n };\n\n \/\/ \u505a\u4e00\u4e9b\u5176\u4ed6\u64cd\u4f5c...\n \/\/ ...\n\n deferredProcess(); \/\/ \u6700\u7ec8\u5904\u7406\u8d44\u6e90\n}<\/code><\/pre>\n\n\n\n\n- Synchronizing data access in multiple threads<\/li>\n<\/ol>\n\n\n\n
int main() {\n std::vector<int> data;\n std::mutex data_mutex;\n std::vector<std::thread> threadsPool;\n\n \/\/ Lambda\u7528\u4e8e\u6dfb\u52a0\u6570\u636e\u5230vector\uff0c\u786e\u4fdd\u7ebf\u7a0b\u5b89\u5168\n auto addData = [&](int value) {\n std::lock_guard<std::mutex> lock(data_mutex);\n data.push_back(value);\n std::cout << \"Added \" << value << \" to the data structure.\" << std::endl;\n };\n\n threadsPool.reserve(10);\n for (int i = 0; i < 10; ++i) {\n threadsPool.emplace_back(addData, i);\n }\n\n \/\/ \u7b49\u5f85\u6240\u6709\u7ebf\u7a0b\u5b8c\u6210\n for (auto& thread : threadsPool) {\n thread.join();\n }\n}<\/code><\/pre>\n\n\n\n\n- Application of Lambda in range query<\/li>\n<\/ol>\n\n\n\n
#include <algorithm>\n\nint main() {\n std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\n int lower_bound = 3;\n int upper_bound = 7;\n\n \/\/ \u4f7f\u7528Lambda\u627e\u5230\u7279\u5b9a\u8303\u56f4\u5185\u7684\u6240\u6709\u6570\n auto range_begin = std::find_if(v.begin(), v.end(), [lower_bound](int x) { return x >= lower_bound; });\n auto range_end = std::find_if(range_begin, v.end(), [upper_bound](int x) { return x > upper_bound; });\n\n std::cout << \"Range: \";\n std::for_each(range_begin, range_end, [](int x) { std::cout << x << ' '; });\n std::cout << std::endl;\n}<\/code><\/pre>\n\n\n\n\n- Delayed execution<\/li>\n<\/ol>\n\n\n\n
#include <chrono>\n\n\/\/ \u6a21\u62df\u4e00\u4e2a\u53ef\u80fd\u9700\u8981\u8017\u65f6\u7684\u64cd\u4f5c\nvoid expensiveOperation(int data) {\n \/\/ \u6a21\u62df\u8017\u65f6\u64cd\u4f5c\n std::this_thread::sleep_for(std::chrono::seconds(1));\n std::cout << \"Processed data: \" << data << std::endl;\n}\n\nint main() {\n std::vector<std::function<void()>> deferredOperations;\n\n deferredOperations.reserve(10);\n \/\/ \u5047\u8bbe\u8fd9\u662f\u4e00\u4e2a\u9700\u8981\u6267\u884c\u8017\u65f6\u64cd\u4f5c\u7684\u5faa\u73af\uff0c\u4f46\u6211\u4eec\u4e0d\u60f3\u7acb\u5373\u6267\u884c\u5b83\u4eec\n for (int i = 0; i < 10; ++i) {\n \/\/ \u6355\u83b7i\u5e76\u5ef6\u8fdf\u6267\u884c\n deferredOperations.emplace_back([i] {\n expensiveOperation(i);\n });\n }\n\n std::cout << \"All operations have been scheduled, doing other work now.\" << std::endl;\n\n \/\/ \u5047\u8bbe\u73b0\u5728\u662f\u4e00\u4e2a\u8f83\u597d\u7684\u65f6\u95f4\u70b9\u53bb\u6267\u884c\u8fd9\u4e9b\u8017\u65f6\u7684\u64cd\u4f5c\n for (auto& operation : deferredOperations) {\n \/\/ \u5728\u4e00\u4e2a\u65b0\u7ebf\u7a0b\u4e0a\u6267\u884cLambda\u8868\u8fbe\u5f0f\u4ee5\u907f\u514d\u963b\u585e\u4e3b\u7ebf\u7a0b\n std::thread(operation).detach();\n }\n\n \/\/ \u7ed9\u7ebf\u7a0b\u4e00\u4e9b\u65f6\u95f4\u6765\u5904\u7406\u64cd\u4f5c\n std::this_thread::sleep_for(std::chrono::seconds(2));\n std::cout << \"Main thread finished.\" << std::endl;\n}\n\/* \u6ce8\u610f\uff1a\u5728\u5b9e\u9645\u7684\u591a\u7ebf\u7a0b\u7a0b\u5e8f\u4e2d\uff0c\u901a\u5e38\u9700\u8981\u8003\u8651\u7ebf\u7a0b\u540c\u6b65\u548c\u8d44\u6e90\u7ba1\u7406\n\uff0c\u4f8b\u5982\u4f7f\u7528 std::async \u800c\u4e0d\u662f std::thread().detach()\uff0c\n\u4ee5\u53ca\u4f7f\u7528\u9002\u5f53\u7684\u540c\u6b65\u673a\u5236\u5982\u4e92\u65a5\u9501\u548c\u6761\u4ef6\u53d8\u91cf\u6765\u4fdd\u8bc1\u7ebf\u7a0b\u5b89\u5168\u3002\n\u5728\u8fd9\u4e2a\u7b80\u5316\u7684\u4f8b\u5b50\u4e2d\uff0c\u4e3a\u4e86\u4fdd\u6301\u6e05\u6670\u548c\u96c6\u4e2d\u5728\u5ef6\u8fdf\u64cd\u4f5c\u4e0a\uff0c\n\u8fd9\u4e9b\u7ec6\u8282\u88ab\u7701\u7565\u4e86\u3002*\/\n\n\/\/ \u4e0b\u9762\u6f14\u793a\u8fd9\u4e2a\u4f8b\u5b50\u66f4\u5408\u7406\u7684\u7248\u672c\n\n#include <iostream>\n#include <vector>\n#include <future>\n#include <chrono>\n\/\/ \u6a21\u62df\u4e00\u4e2a\u53ef\u80fd\u9700\u8981\u8017\u65f6\u7684\u64cd\u4f5c\nint expensiveOperation(int data) {\n \/\/ \u6a21\u62df\u8017\u65f6\u64cd\u4f5c\n std::this_thread::sleep_for(std::chrono::seconds(1));\n return data * data; \/\/ \u8fd4\u56de\u4e00\u4e9b\u5904\u7406\u7ed3\u679c\n}\nint main() {\n std::vector<std::future<int>> deferredResults;\n \/\/ \u542f\u52a8\u591a\u4e2a\u5f02\u6b65\u4efb\u52a1\n deferredResults.reserve(10);\n for (int i = 0; i < 10; ++i) {\n deferredResults.emplace_back(\n std::async(std::launch::async, expensiveOperation, i)\n );\n }\n std::cout << \"All operations have been scheduled, doing other work now.\" << std::endl;\n \/\/ \u83b7\u53d6\u5f02\u6b65\u4efb\u52a1\u7684\u7ed3\u679c\n for (auto& future : deferredResults) {\n \/\/ get() \u4f1a\u963b\u585e\u76f4\u5230\u5f02\u6b65\u64cd\u4f5c\u5b8c\u6210\u5e76\u8fd4\u56de\u7ed3\u679c\n std::cout << \"Processed data: \" << future.get() << std::endl;\n }\n std::cout << \"Main thread finished.\" << std::endl;\n}\n\/* \u5907\u6ce8\uff1astd::async \u4e3a\u6211\u4eec\u7ba1\u7406\u4e86\u8fd9\u4e00\u5207\u3002\n\u6211\u4eec\u4e5f\u4e0d\u9700\u8981\u4f7f\u7528\u4e92\u65a5\u9501\u6216\u5176\u4ed6\u540c\u6b65\u673a\u5236\uff0c\u56e0\u4e3a\u6bcf\u4e2a\u5f02\u6b65\u64cd\u4f5c\u90fd\u5728\u5b83\u81ea\u5df1\u7684\u7ebf\u7a0b\u4e0a\u8fd0\u884c\uff0c\n\u4e0d\u4f1a\u4e92\u76f8\u5e72\u6270\uff0c\u5e76\u4e14\u8fd4\u56de\u7684 future \u5bf9\u8c61\u4e3a\u6211\u4eec\u5904\u7406\u4e86\u6240\u6709\u5fc5\u8981\u7684\u540c\u6b65\u3002\nstd::async \u4e0e std::launch::async \u53c2\u6570\u4e00\u8d77\u4f7f\u7528\uff0c\n \u8fd9\u4f1a\u4fdd\u8bc1\u6bcf\u4e2a\u4efb\u52a1\u90fd\u5728\u4e0d\u540c\u7684\u7ebf\u7a0b\u4e0a\u5f02\u6b65\u8fd0\u884c\u3002\n\u5982\u679c\u4f60\u6ca1\u6709\u6307\u5b9a std::launch::async\uff0cC++ \u8fd0\u884c\u65f6\u53ef\u4ee5\u51b3\u5b9a\u540c\u6b65\uff08\u5ef6\u8fdf\uff09\u6267\u884c\u4efb\u52a1\uff0c\n\u8fd9\u5e76\u4e0d\u662f\u6211\u4eec\u5e0c\u671b\u770b\u5230\u7684\u3002\n future.get() \u8c03\u7528\u5c06\u963b\u585e\u4e3b\u7ebf\u7a0b\uff0c\u76f4\u5230\u76f8\u5e94\u7684\u4efb\u52a1\u5b8c\u6210\uff0c\u5e76\u8fd4\u56de\u7ed3\u679c\u3002\n\u8fd9\u4f7f\u5f97\u6211\u4eec\u53ef\u4ee5\u5b89\u5168\u5730\u83b7\u53d6\u7ed3\u679c\uff0c\u800c\u4e0d\u4f1a\u53d1\u751f\u7ade\u4e89\u6761\u4ef6\u6216\u8005\u9700\u8981\u4f7f\u7528\u4e92\u65a5\u9501\u3002*\/<\/code><\/pre>\n\n\n\n4. mutable keyword<\/h3>\n\n\n\n
First, let's review what the mutable keyword is. In addition to being used in lambda expressions, we also generally use it in class member declarations.<\/p>\n\n\n\n
When in aClass member variables<\/strong>When you use the mutable keyword, you can modify this member variable in the const member function of the class. This is usually used for members that do not affect the external state of the object, such as caches, debugging information, or data that can be calculated lazily.<\/p>\n\n\n\nclass MyClass {\npublic:\n mutable int cache; \/\/ \u53ef\u4ee5\u5728const\u6210\u5458\u51fd\u6570\u4e2d\u4fee\u6539\n int data;\n\n MyClass() : data(0), cache(0) {}\n\n void setData(int d) const {\n \/\/ data = d; \/\/ \u7f16\u8bd1\u9519\u8bef\uff1a\u4e0d\u80fd\u5728const\u51fd\u6570\u4e2d\u4fee\u6539\u975emutable\u6210\u5458\n cache = d;\n }\n};<\/code><\/pre>\n\n\n\nIn lambda expressions<\/strong>, the mutable keyword allows you to modify the copy of the variable captured inside the Lambda. By default, the () in the Lambda expression is const, and generally you cannot modify the variable captured by value. Unless you use mutable.<\/p>\n\n\n\nHereKey Points<\/strong>Mutable allows modification of the closure's own member variablesInstances<\/strong>, rather than the original variables in the outer scope. This means that the closure has "Closedness" is still maintained<\/strong>, because it does not change the state of the outer scope, but only changes its own internal state.<\/p>\n\n\n\nInvalid example:<\/p>\n\n\n\n
int x = 0; auto f = [x]() { x++; \/\/ error: cannot modify captured variable}; f();<\/code><\/pre>\n\n\n\nIt should be like this:<\/p>\n\n\n\n
int x = 0; auto f = [x]() mutable { x++; std::cout << x << std::endl; }; f(); \/\/ Correct: outputs 1<\/code><\/pre>\n\n\n\nPractical example:<\/p>\n\n\n\n
\n- Capturing variable modifications<\/li>\n<\/ol>\n\n\n\n
#include <iostream>\n#include <vector>\n\nint main() {\n int count = 0;\n\n \/\/ \u521b\u5efa\u4e00\u4e2a\u53ef\u53d8lambda\u8868\u8fbe\u5f0f\uff0c\u6bcf\u6b21\u8c03\u7528\u90fd\u9012\u589ecount\n auto increment = [count]() mutable {\n count++;\n std::cout << count << std::endl;\n };\n\n increment(); \/\/ \u8f93\u51fa 1\n increment(); \/\/ \u8f93\u51fa 2\n increment(); \/\/ \u8f93\u51fa 3\n\n \/\/ \u5916\u90e8\u7684count\u4ecd\u7136\u662f0\uff0c\u56e0\u4e3a\u5b83\u662f\u901a\u8fc7\u503c\u6355\u83b7\u7684\n std::cout << \"External count: \" << count << std::endl; \/\/ \u8f93\u51fa External count: 0\n}<\/code><\/pre>\n\n\n\n\n- Generate a unique ID<\/li>\n<\/ol>\n\n\n\n
#include <iostream>\n\nint main() {\n int lastId = 0;\n\n auto generateId = [lastId]() mutable -> int {\n return ++lastId; \/\/ \u9012\u589e\u5e76\u8fd4\u56de\u65b0\u7684ID\n };\n\n std::cout << \"New ID: \" << generateId() << std::endl; \/\/ \u8f93\u51fa New ID: 1\n std::cout << \"New ID: \" << generateId() << std::endl; \/\/ \u8f93\u51fa New ID: 2\n std::cout << \"New ID: \" << generateId() << std::endl; \/\/ \u8f93\u51fa New ID: 3\n}<\/code><\/pre>\n\n\n\n\n- State retention<\/li>\n<\/ol>\n\n\n\n
#include <iostream>\n#include <algorithm>\n#include <vector>\n\nint main() {\n std::vector<int> numbers = {1, 2, 3, 4, 5};\n\n \/\/ \u521d\u59cb\u72b6\u6001\n int accumulator = 0;\n\n \/\/ \u521b\u5efa\u4e00\u4e2a\u53ef\u53d8lambda\u8868\u8fbe\u5f0f\u6765\u7d2f\u52a0\u503c\n auto sum = [accumulator](int value) mutable {\n accumulator += value;\n return accumulator; \/\/ \u8fd4\u56de\u5f53\u524d\u7d2f\u52a0\u503c\n };\n\n std::vector<int> runningTotals(numbers.size());\n\n \/\/ \u5bf9\u6bcf\u4e2a\u5143\u7d20\u5e94\u7528sum\uff0c\u751f\u6210\u8fd0\u884c\u603b\u548c\n std::transform(numbers.begin(), numbers.end(), runningTotals.begin(), sum);\n\n \/\/ \u8f93\u51fa\u8fd0\u884c\u603b\u548c\n for (int total : runningTotals) {\n std::cout << total << \" \"; \/\/ \u8f93\u51fa 1 3 6 10 15\n }\n std::cout << std::endl;\n}<\/code><\/pre>\n\n\n\n5. Lambda return value deduction<\/h3>\n\n\n\n
When lambda expressions were introduced in C++11, the return type of the lambda usually needed to be explicitly specified.<\/p>\n\n\n\n
Starting from C++14, the deduction of Lambda return values has been improved and automatic type deduction has been introduced.<\/p>\n\n\n\n
The deduction of lambda return values in C++14 follows the following rules:<\/p>\n\n\n\n
\n- If the lambda function body contains the return keyword, and the type of the expressions following all return statements is the same, then the lambda return type is deduced to be that type.<\/li>\n\n\n\n
- If the body of the lambda function is a single return statement, or can be considered a single return statement (such as a constructor or brace initializer), the return type is inferred to be the type of the return statement expression.<\/li>\n\n\n\n
- If the lambda function does not return any value (i.e. there is no return statement in the function body), or if the function body contains only return statements that do not return a value (i.e. return;), the deduced return type is void.<\/li>\n\n\n\n
- C++11 return value deduction example<\/strong><\/li>\n<\/ol>\n\n\n\n
In C++11, if the lambda body contains multiple return statements, the return type must be explicitly specified.<\/p>\n\n\n\n
auto f = [](int x) -> double { \/\/ explicitly specify the return type if (x > 0) return x * 2.5; else return x \/ 2.0; };<\/code><\/pre>\n\n\n\n\n- C++14 automatic deduction<\/strong><\/li>\n<\/ul>\n\n\n\n
In C++14, the return type of the above lambda expression can be automatically deduced.<\/p>\n\n\n\n
auto f = [](int x) { \/\/ The return type is automatically deduced to double if (x > 0) return x * 2.5; \/\/ double else return x \/ 2.0; \/\/ double };<\/code><\/pre>\n\n\n\n\n- Error demonstration<\/strong><\/li>\n<\/ul>\n\n\n\n
If the type of the return statement does not match, it cannot be automatically deduced, which will result in a compilation error.<\/p>\n\n\n\n
auto g = [](int x) { \/\/ Compilation error because the return type is inconsistent if (x > 0) return x * 2.5; \/\/ double else return x; \/\/ int };<\/code><\/pre>\n\n\n\nBut after C++17, if the return types are so different that they cannot be unified into a common type directly or through conversion, you can use std::variant or std::any, which can contain multiple different types:<\/p>\n\n\n\n
#include <variant>\n\nauto g = [](int x) -> std::variant<int, double> {\n if (x > 0)\n return x * 2.5; \/\/ \u8fd4\u56dedouble\u7c7b\u578b\n else\n return x; \/\/ \u8fd4\u56deint\u7c7b\u578b\n};<\/code><\/pre>\n\n\n\nThe lambda expression returns a std::variant type, that is, a superposition state of int or double type, and subsequent callers can then check this variable and handle it accordingly. This part will not be discussed in detail.<\/p>\n\n\n\n
6. Nested Lambda<\/h3>\n\n\n\n
It can also be called nested lambda, which is an advanced functional programming technique to write a lambda inside a lambda.<\/p>\n\n\n\n
Here is a simple example:<\/p>\n\n\n\n
#include <iostream>\n#include <vector>\n#include <algorithm>\n\nint main() {\n std::vector<int> numbers = {1, 2, 3, 4, 5};\n\n \/\/ \u5916\u5c42Lambda\u7528\u4e8e\u904d\u5386\u96c6\u5408\n std::for_each(numbers.begin(), numbers.end(), [](int x) {\n \/\/ \u5d4c\u5957Lambda\u7528\u4e8e\u8ba1\u7b97\u5e73\u65b9\n auto square = [](int y) { return y * y; };\n\n \/\/ \u8c03\u7528\u5d4c\u5957Lambda\u5e76\u6253\u5370\u7ed3\u679c\n std::cout << square(x) << ' ';\n });\n\n std::cout << std::endl;\n return 0;\n}<\/code><\/pre>\n\n\n\nBut we need to pay attention to many issues:<\/p>\n\n\n\n
\n- Don't make it too complicated; readability is the main consideration.<\/li>\n\n\n\n
- Note the lifetime of variables in the capture list, which will also be discussed in detail in the following examples.<\/li>\n\n\n\n
- Capture lists should be kept as simple as possible to avoid errors.<\/li>\n\n\n\n
- The compiler may not optimize nested lambdas as well as top-level functions or class member functions.<\/li>\n<\/ol>\n\n\n\n
If a nested Lambda captures local variables of an outer Lambda, you need to pay attention to the lifecycle of the variables. If the execution of the nested Lambda continues beyond the lifecycle of the outer Lambda, the captured local variables will no longer be valid and an error will be reported.<\/p>\n\n\n\n
#include <iostream>\n#include <functional>\n\nstd::function<int()> createLambda() {\n int localValue = 10; \/\/ \u5916\u5c42Lambda\u7684\u5c40\u90e8\u53d8\u91cf\n\n \/\/ \u8fd4\u56de\u4e00\u4e2a\u6355\u83b7localValue\u7684Lambda\n return [localValue]() mutable {\n return ++localValue; \/\/ \u8bd5\u56fe\u4fee\u6539\u6355\u83b7\u7684\u53d8\u91cf\uff08\u7531\u4e8e\u662f\u503c\u6355\u83b7\uff0c\u8fd9\u662f\u5408\u6cd5\u7684\uff09\n };\n}\n\nint main() {\n auto myLambda = createLambda(); \/\/ myLambda\u73b0\u5728\u6301\u6709\u4e00\u4e2a\u6355\u83b7\u4e86\u5df2\u7ecf\u9500\u6bc1\u7684\u5c40\u90e8\u53d8\u91cf\u7684\u526f\u672c\n\n std::cout << myLambda() << std::endl; \/\/ \u8fd9\u5c06\u8f93\u51fa11\uff0c\u4f46\u662f\u4f9d\u8d56\u4e8e\u5df2\u7ecf\u9500\u6bc1\u7684localValue\u7684\u526f\u672c\n std::cout << myLambda() << std::endl; \/\/ \u518d\u6b21\u8c03\u7528\u5c06\u8f93\u51fa12\uff0c\u7ee7\u7eed\u4f9d\u8d56\u4e8e\u90a3\u4e2a\u526f\u672c\n\n return 0;\n}<\/code><\/pre>\n\n\n\nTo explain, since Lambda captures localValue by value, it holds a copy of localValue, and the life cycle of this copy is the same as that of the returned Lambda object.<\/p>\n\n\n\n
When we call myLambda() in the main function, it operates on the state of the localValue copy, not the original localValue (which has been destroyed after the createLambda function is executed). Although undefined behavior is not triggered here, the situation will be different if we use reference capture:<\/p>\n\n\n\n
std::function<int()> createLambda() {\n int localValue = 10; \/\/ \u5916\u5c42Lambda\u7684\u5c40\u90e8\u53d8\u91cf\n\n \/\/ \u8fd4\u56de\u4e00\u4e2a\u6355\u83b7localValue\u5f15\u7528\u7684Lambda\n return [&localValue]() mutable {\n return ++localValue; \/\/ \u8bd5\u56fe\u4fee\u6539\u6355\u83b7\u7684\u53d8\u91cf\n };\n}\n\/\/ \u6b64\u65f6\u4f7f\u7528createLambda\u8fd4\u56de\u7684Lambda\u5c06\u4f1a\u5bfc\u81f4\u672a\u5b9a\u4e49\u884c\u4e3a<\/code><\/pre>\n\n\n\n7. Lambda, std:function and delegates<\/h3>\n\n\n\n
Lambda expression, std::function and delegate are three different concepts used to implement function call and callback mechanism in C++. Next, we will explain them one by one.<\/p>\n\n\n\n
\n- Lambda<\/strong><\/li>\n<\/ul>\n\n\n\n
C++11 introduces a syntax for defining anonymous function objects. Lambda is used to create a callable entity, namely a Lambda closure, which is usually passed to an algorithm or used as a callback function. Lambda expressions can capture variables in scope, either by value (copy) or by reference. Lambda expressions are defined inside functions, their types are unique, and cannot be explicitly specified.<\/p>\n\n\n\n
auto lambda = [](int a, int b) { return a + b; }; auto result = lambda(2, 3); \/\/ Calling Lambda Expression<\/code><\/pre>\n\n\n\n\n- std::function<\/li>\n<\/ul>\n\n\n\n
std::function is a type-erased wrapper introduced in C++11 that canstorage<\/strong>,Call<\/strong>andcopy<\/strong>Any callable entity, such as function pointers, member function pointers, lambda expressions, and function objects. The cost is that the overhead is large.<\/p>\n\n\n\nstd::function func = lambda; auto result = func(2, 3); \/\/ Call the Lambda expression using the std::function object<\/code><\/pre>\n\n\n\n\n- Delegation<\/strong><\/li>\n<\/ul>\n\n\n\n
Delegate is not a formal term in C++. Delegate is usually a mechanism to delegate function calls to other objects. In C#, a delegate is a type-safe function pointer. In C++, there are generally several ways to implement delegates: function pointer, member function pointer, std::function and function object. The following is an example of a delegate constructor.<\/p>\n\n\n\n
class MyClass {\npublic:\n MyClass(int value) : MyClass(value, \"default\") { \/\/ \u59d4\u6258\u7ed9\u53e6\u4e00\u4e2a\u6784\u9020\u51fd\u6570\n std::cout << \"Constructor with single parameter called.\" << std::endl;\n }\n\n MyClass(int value, std::string text) {\n std::cout << \"Constructor with two parameters called: \" << value << \", \" << text << std::endl;\n }\n};\n\nint main() {\n MyClass obj(30); \/\/ \u8fd9\u5c06\u8c03\u7528\u4e24\u4e2a\u6784\u9020\u51fd\u6570\n}<\/code><\/pre>\n\n\n\n\n- Comparison of the three<\/strong><\/li>\n<\/ul>\n\n\n\n
Lambda Expressions<\/strong>It is lightweight and well suited for defining simple local callbacks and as parameters to algorithms.<\/p>\n\n\n\nstd::function is heavier, but more flexible. For example, if you have a scenario where you need to store different types of callback functions, std::function is an ideal choice because it can store any type of callable entity. An example that demonstrates its flexibility.<\/p>\n\n\n\n
#include <iostream>\n#include <functional>\n#include <vector>\n\n\/\/ \u4e00\u4e2a\u63a5\u6536int\u5e76\u8fd4\u56devoid\u7684\u51fd\u6570\nvoid printNumber(int number) {\n std::cout << \"Number: \" << number << std::endl;\n}\n\n\/\/ \u4e00\u4e2aLambda\u8868\u8fbe\u5f0f\nauto printSum = [](int a, int b) {\n std::cout << \"Sum: \" << (a + b) << std::endl;\n};\n\n\/\/ \u4e00\u4e2a\u51fd\u6570\u5bf9\u8c61\nclass PrintMessage {\npublic:\n void operator()(const std::string &message) const {\n std::cout << \"Message: \" << message << std::endl;\n }\n};\n\nint main() {\n \/\/ \u521b\u5efa\u4e00\u4e2astd::function\u7684\u5411\u91cf\uff0c\u53ef\u4ee5\u5b58\u50a8\u4efb\u4f55\u7c7b\u578b\u7684\u53ef\u8c03\u7528\u5bf9\u8c61\n std::vector<std::function<void()>> callbacks;\n\n \/\/ \u6dfb\u52a0\u4e00\u4e2a\u666e\u901a\u51fd\u6570\u7684\u56de\u8c03\n int number_to_print = 42;\n callbacks.push_back([=]{ printNumber(number_to_print); });\n\n \/\/ \u6dfb\u52a0\u4e00\u4e2aLambda\u8868\u8fbe\u5f0f\u7684\u56de\u8c03\n int a = 10, b = 20;\n callbacks.push_back([=]{ printSum(a, b); });\n\n \/\/ \u6dfb\u52a0\u4e00\u4e2a\u51fd\u6570\u5bf9\u8c61\u7684\u56de\u8c03\n std::string message = \"Hello World\";\n PrintMessage printMessage;\n callbacks.push_back([=]{ printMessage(message); });\n\n \/\/ \u6267\u884c\u6240\u6709\u7684\u56de\u8c03\n for (auto& callback : callbacks) {\n callback();\n }\n\n return 0;\n}<\/code><\/pre>\n\n\n\nDelegation<\/strong>Usually related to event handling. There is no built-in event handling mechanism in C++, so std::function and Lambda expressions are often used to implement the delegation pattern. Specifically, you define a callback interface, and users can register their own functions or Lambda expressions to this interface so that they can be called when an event occurs. The general steps are as follows (by the way, an example):<\/p>\n\n\n\n\n- Defines the types that can be called<\/strong>: You need to determine what parameters your callback function or Lambda expression needs to accept and what type of result it returns.<\/li>\n<\/ol>\n\n\n\n
using Callback = std::function ; \/\/ callback with no parameters and return value<\/code><\/pre>\n\n\n\n\n- Create a class to manage callbacks<\/strong>: This class will hold all callback functions and allow users to add or remove callbacks.<\/li>\n<\/ol>\n\n\n\n
class Button {\nprivate:\n std::vector<Callback> onClickCallbacks; \/\/ \u5b58\u50a8\u56de\u8c03\u7684\u5bb9\u5668\n\npublic:\n void addClickListener(const Callback& callback) {\n onClickCallbacks.push_back(callback);\n }\n\n void click() {\n for (auto& callback : onClickCallbacks) {\n callback(); \/\/ \u6267\u884c\u6bcf\u4e00\u4e2a\u56de\u8c03\n }\n }\n};<\/code><\/pre>\n\n\n\n\n- Provide a method to add a callback<\/strong>: This method allows users to add their own functions or Lambda expressionsRegister as callback<\/strong>.<\/li>\n<\/ol>\n\n\n\n
Button button; button.addClickListener([]() { std::cout << "Button was clicked!" << std::endl; });<\/code><\/pre>\n\n\n\n\n- Provide a method to execute the callback<\/strong>\uff1aWhen necessary, this method willCall all registered callback functions<\/strong>.<\/li>\n<\/ol>\n\n\n\n
button.click(); \/\/ User clicks the button to trigger all callbacks<\/code><\/pre>\n\n\n\nIsn\u2019t it very simple? Let\u2019s take another example to deepen our understanding.<\/p>\n\n\n\n
#include <functional>\n#include <iostream>\n#include <vector>\n\nclass Delegate {\npublic:\n using Callback = std::function<void(int)>; \/\/ \u5b9a\u4e49\u56de\u8c03\u7c7b\u578b\uff0c\u8fd9\u91cc\u7684\u56de\u8c03\u63a5\u6536\u4e00\u4e2aint\u53c2\u6570\n\n \/\/ \u6ce8\u518c\u56de\u8c03\u51fd\u6570\n void registerCallback(const Callback& callback) {\n callbacks.push_back(callback);\n }\n\n \/\/ \u89e6\u53d1\u6240\u6709\u56de\u8c03\u51fd\u6570\n void notify(int value) {\n for (const auto& callback : callbacks) {\n callback(value); \/\/ \u6267\u884c\u56de\u8c03\n }\n }\n\nprivate:\n std::vector<Callback> callbacks; \/\/ \u5b58\u50a8\u56de\u8c03\u7684\u5bb9\u5668\n};\n\nint main() {\n Delegate del;\n\n \/\/ \u7528\u6237\u6ce8\u518c\u81ea\u5df1\u7684\u51fd\u6570\n del.registerCallback([](int n) {\n std::cout << \"Lambda 1: \" << n << std::endl;\n });\n\n \/\/ \u53e6\u4e00\u4e2aLambda\u8868\u8fbe\u5f0f\n del.registerCallback([](int n) {\n std::cout << \"Lambda 2: \" << n * n << std::endl;\n });\n\n \/\/ \u89e6\u53d1\u56de\u8c03\n del.notify(10); \/\/ \u8fd9\u5c06\u8c03\u7528\u6240\u6709\u6ce8\u518c\u7684Lambda\u8868\u8fbe\u5f0f\n\n return 0;\n}<\/code><\/pre>\n\n\n\n8. Lambda in asynchronous and concurrent programming<\/h3>\n\n\n\n
All because Lambda has the function of capturing and storing state, which makes it very useful when we write modern C++ concurrent programming.<\/p>\n\n\n\n
\n- Lambda and Threads<\/strong><\/li>\n<\/ul>\n\n\n\n
Use lambda expressions directly in the std::thread constructor to define the code that the thread should execute.<\/p>\n\n\n\n
#include <thread>\n#include <iostream>\n\nint main() {\n int value = 42;\n\n \/\/ \u521b\u5efa\u4e00\u4e2a\u65b0\u7ebf\u7a0b\uff0c\u4f7f\u7528 Lambda \u8868\u8fbe\u5f0f\u4f5c\u4e3a\u7ebf\u7a0b\u51fd\u6570\n std::thread worker([value]() {\n std::cout << \"Value in thread: \" << value << std::endl;\n });\n\n \/\/ \u4e3b\u7ebf\u7a0b\u7ee7\u7eed\u6267\u884c...\n\n \/\/ \u7b49\u5f85\u5de5\u4f5c\u7ebf\u7a0b\u5b8c\u6210\n worker.join();\n\n return 0;\n}<\/code><\/pre>\n\n\n\n\n- Lambda and<\/strong> std::async<\/strong><\/li>\n<\/ul>\n\n\n\n
std::async is a tool that allows you to easily create asynchronous functions. After the calculation is completed, it returns a std::future object. You can call get, but it will block if the execution is not completed. There are many interesting things about async, which I will not go into here.<\/p>\n\n\n\n
#include <future>\n#include <iostream>\n\nint main() {\n \/\/ \u542f\u52a8\u4e00\u4e2a\u5f02\u6b65\u4efb\u52a1\n auto future = std::async([]() {\n \/\/ \u6267\u884c\u4e00\u4e9b\u64cd\u4f5c...\n return \"Result from async task\";\n });\n\n \/\/ \u5728\u6b64\u671f\u95f4\uff0c\u4e3b\u7ebf\u7a0b\u53ef\u4ee5\u6267\u884c\u5176\u4ed6\u4efb\u52a1...\n\n \/\/ \u83b7\u53d6\u5f02\u6b65\u64cd\u4f5c\u7684\u7ed3\u679c\n std::string result = future.get();\n std::cout << result << std::endl;\n\n return 0;\n}<\/code><\/pre>\n\n\n\n\n- Lambda and<\/strong> std::funtion<\/strong><\/li>\n<\/ul>\n\n\n\n
These two are often used together, so let's take an example of storing a callable callback.<\/p>\n\n\n\n
#include <functional>\n#include <vector>\n#include <iostream>\n#include <thread>\n\n\/\/ \u4e00\u4e2a\u5b58\u50a8 std::function \u5bf9\u8c61\u7684\u4efb\u52a1\u961f\u5217\nstd::vector<std::function<void()>> tasks;\n\n\/\/ \u6dfb\u52a0\u4efb\u52a1\u7684\u51fd\u6570\nvoid addTask(const std::function<void()>& task) {\n tasks.push_back(task);\n}\n\nint main() {\n \/\/ \u6dfb\u52a0\u4e00\u4e2a Lambda \u8868\u8fbe\u5f0f\u4f5c\u4e3a\u4efb\u52a1\n addTask([]() {\n std::cout << \"Task 1 executed\" << std::endl;\n });\n\n \/\/ \u542f\u52a8\u4e00\u4e2a\u65b0\u7ebf\u7a0b\u6765\u5904\u7406\u4efb\u52a1\n std::thread worker([]() {\n for (auto& task : tasks) {\n task(); \/\/ \u6267\u884c\u4efb\u52a1\n }\n });\n\n \/\/ \u4e3b\u7ebf\u7a0b\u7ee7\u7eed\u6267\u884c...\n worker.join();\n\n return 0;\n}<\/code><\/pre>\n\n\n\n9. Generic Lambda (C++14)<\/h3>\n\n\n\n
Use the auto keyword to perform type inference in the argument list.<\/p>\n\n\n\n
Generic basic syntax:<\/strong><\/p>\n\n\n\nauto lambda = [](auto x, auto y) { return x + y; };<\/code><\/pre>\n\n\n\nExample:<\/p>\n\n\n\n
#include <numeric>\n\nint main() {\n std::vector<int> vi = {1, 2, 3, 4};\n std::vector<double> vd = {1.1, 2.2, 3.3, 4.4, 5.5};\n\n \/\/ \u4f7f\u7528\u6cdb\u578b Lambda \u6253\u5370 int \u7c7b\u578b\u7684\u5143\u7d20\n std::for_each(vi.begin(), vi.end(), [](auto n) {\n std::cout << n << ' ';\n });\n std::cout << '\\n';\n\n \/\/ \u4f7f\u7528\u6cdb\u578b Lambda \u6253\u5370 double \u7c7b\u578b\u7684\u5143\u7d20\n std::for_each(vd.begin(), vd.end(), [](auto n) {\n std::cout << n << ' ';\n });\n std::cout << '\\n';\n\n \/\/ \u4f7f\u7528\u6cdb\u578b Lambda \u8ba1\u7b97 int \u7c7b\u578b\u7684\u5411\u91cf\u7684\u548c\n auto sum_vi = std::accumulate(vi.begin(), vi.end(), 0, [](auto total, auto n) {\n return total + n;\n });\n std::cout << \"Sum of vi: \" << sum_vi << '\\n';\n\n \/\/ \u4f7f\u7528\u6cdb\u578b Lambda \u8ba1\u7b97 double \u7c7b\u578b\u7684\u5411\u91cf\u7684\u548c\n auto sum_vd = std::accumulate(vd.begin(), vd.end(), 0.0, [](auto total, auto n) {\n return total + n;\n });\n std::cout << \"Sum of vd: \" << sum_vd << '\\n';\n\n return 0;\n}<\/code><\/pre>\n\n\n\nIt is also possible to make a lambda that prints any type of container.<\/p>\n\n\n\n
#include <list>\n\nint main() {\n std::vector<int> vec{1, 2, 3, 4};\n std::list<double> lst{1.1, 2.2, 3.3, 4.4};\n\n auto print = [](const auto& container) {\n for (const auto& val : container) {\n std::cout << val << ' ';\n }\n std::cout << '\\n';\n };\n\n print(vec); \/\/ \u6253\u5370 vector<int>\n print(lst); \/\/ \u6253\u5370 list<double>\n\n return 0;\n}<\/code><\/pre>\n\n\n\n10. Lambda Scope<\/h3>\n\n\n\n
First, Lambda can capture local variables within the scope in which it is defined. After capture, even if the original scope ends, copies or references of these variables (depending on the capture method) can still continue to be used.<\/p>\n\n\n\n
It is important to note that if a variable is captured by reference and the original scope of the variable has been destroyed, this will lead to undefined behavior.<\/p>\n\n\n\n
Lambda can also capture global variables, but this is not achieved through a capture list, because global variables can be accessed from anywhere.<\/p>\n\n\n\n
If you have a lambda nested inside another lambda, the inner lambda can capture variables in the capture list of the outer lambda.<\/p>\n\n\n\n
When Lambda captures a value, even if the original value is gone and Lambda is gone (returned to somewhere else), all variables captured by the value will be copied to the Lambda object. The life cycle of these variables will automatically continue until the Lambda object itself is destroyed. Here is an example:<\/p>\n\n\n\n
#include <iostream>\n#include <functional>\n\nstd::function<void()> createLambda() {\n int localValue = 100; \/\/ \u5c40\u90e8\u53d8\u91cf\n return [=]() mutable { \/\/ \u4ee5\u503c\u6355\u83b7\u7684\u65b9\u5f0f\u590d\u5236localValue\n std::cout << localValue++ << '\\n';\n };\n}\n\nint main() {\n auto myLambda = createLambda(); \/\/ Lambda\u590d\u5236\u4e86localValue\n myLambda(); \/\/ \u5373\u4f7fcreateLambda\u7684\u4f5c\u7528\u57df\u5df2\u7ecf\u7ed3\u675f\uff0c\u590d\u5236\u7684localValue\u4ecd\u7136\u5b58\u5728\u4e8emyLambda\u4e2d\n myLambda(); \/\/ \u53ef\u4ee5\u5b89\u5168\u5730\u7ee7\u7eed\u8bbf\u95ee\u548c\u4fee\u6539\u8be5\u526f\u672c\n}<\/code><\/pre>\n\n\n\nWhen lambda captures a reference, it\u2019s another story. Smart readers should be able to guess that if the scope of the original variable ends, the lambda depends on a dangling reference, which will lead to undefined behavior.<\/p>\n\n\n\n
11. Practice \u2013 Function Compute Library<\/h3>\n\n\n\n
After all this talk, it's time to put it into practice. No matter what you do, the following are the knowledge points you need to master:<\/p>\n\n\n\n
\n- capture<\/li>\n\n\n\n
- Higher-order functions<\/li>\n\n\n\n
- Callable Objects<\/li>\n\n\n\n
- Lambda Storage<\/li>\n\n\n\n
- Mutable Lambdas<\/li>\n\n\n\n
- Generic Lambda<\/li>\n<\/ul>\n\n\n\n