C++20 Lambda表达式捕获模版不定实参（Lambda capture of parameter pack）

最新推荐文章于 2025-09-21 09:08:06 发布

原创最新推荐文章于 2025-09-21 09:08:06 发布 · 886 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c++

C++ 专栏收录该内容

8 篇文章

订阅专栏

本文介绍C++20中Lambda表达式的增强特性，包括如何捕获模板不定长实参，支持传值和引用捕获，展示了C++20在函数式编程方面的进步。

C++20之前Lambda表达式只能捕获固定实参，如：

template <typename T>
auto fun(T&& t){
    return [t = std::forward<T>(t)] {
    };
}

C++20现在可以捕获模版不定长实参了：

template <typename... Args>
auto funs(Args&&... args){
    // 传值捕获
    return [...args = std::forward<Args>(args)] {

    };
}

也可以捕获引用：

template <typename... Args>
auto funs_reference(Args&&... args){
    // 引用捕获
    return [&...args = std::forward<Args>(args)] {

    };
}

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

BranchLin

关注关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

C++(20)：可以获取lambda表达式的类型

风静如云的博客

11-11

137

【代码】C++(20)：可以获取lambda表达式的类型。

C++20 Lambda表达式

如无必要，勿增实体。

10-03

1448

C++20引入了Lambda表达式的一些新特性，主要包括泛型Lambda和constexpr Lambda。泛型Lambda允许Lambda表达式接受模板参数，从而实现更灵活的编程。在这个例子中，auto关键字用于声明模板参数，使得Lambda表达式可以处理不同类型的参数。C++20还引入了constexpr Lambda，这是一种可以在编译时求值的Lambda表达式。使用constexpr。

参与评论您还未登录，请先登录后发表或查看评论

C++20 真正的lambda

weixin_42951026的博客

10-21

549

lambda

C++20模板lambda：vscode-cpptools类型推断

热门推荐

chloe_zh1102的博客

12-11

1万+

文章目录0 前言1 Lambda表达式简介2 捕获列表（Capture List）2.1 按值捕获2.2 按引用捕获2.3 隐式捕获3 小结 0 前言最近通过内部换组来到了新的开发组，组里核心业务用的是C++13，并且十分注重性能和资源的优化。我作为一个C++小白，趁着年底没有太多工作、下一年的项目也还没有启动的空档，看代码之外也花了些时间阅读C++书籍，希望能系统地学习这门语言。最近在看项目代码时发现Lambda表达式在我们的代码中很常见，正好今天在阅读C++ Primer的时候读到了C++ Lam

C++ Lambda 表达式作为类模板参数

OOOOOOAAAAA的博客

02-02

750

学习C++ rbtree时发现第四个模板参数为class _Compare，若不使用标准库自带的less<>等模板目前我只发现通过构造类编写operator()或通过std::function<>才能通过编译 #include <iostream> #include <deque> #include <bits/stl_tree.h> #include <functional> using namespace std; temp.

int** 赋值_C++20 新特性（13）：无状态lambda可以构建和赋值

weixin_39917485的博客

11-28

261

无状态 lambdaC++11标准中新增了 lambda 表达式，可以快速精简的方式构建函数对象，而且还支持闭包，可以简单方便的捕捉当前上下文的对象。由于闭包的存在，又反过来要求闭包本身不可缺省构造和拷贝(拷贝和移动构造函数标记为 deleted )，这样和普通函数对象有区别，影响其应用。因此在C++20中，将有状态的 lambda (捕捉上下文对象形成闭包)和无状态的 lambda (不捕捉上下...

跟着做的C++20教程-实例20-最简单的lambda

愚公

02-17

548

目录实例概要实例代码实例解释实例概要最简单的lambda表达式 实例代码 #include <iostream> #include <string> int main(int argc, char** argv) { auto lambda = [] {std::cout << "I am a lambda" << std::endl; }; lambda(); return 0; } 运行结果 I am a lambda 实例解释

C++ lamda表达式和函数模版用法

天行健，地势坤

08-02

1558

前言本节将对函数对象，匿名函数对象(lamda表达式) 以及匿名函数对象和函数模版结合对一些用法做个笔记。同时，分析以下lamda表达式相比于传统函数对象的优劣。关键是看一些 rocksdb类似的经典C++项目，老是有些细节get不到，导致最终理解的设计思想和实际的实现有差异。所以将这些高阶语法再系统过一遍，加深对源码的理解。函数对象函数对象在C++98的时候已经比较成熟了，先看一段代码 struct adder { adder(int n) : n_(n) {} int

怎么获取泛型的实际类型_C++20 新特性（12）：使用模板语法的泛型lambda

weixin_39708502的博客

11-28

691

在 C++14 中新增泛型lambda时，是使用基于 auto 的语法，比较简单但也带来一定的局限性，因此在 C++20 中进行改进，新增模板语法的泛型 lambda 。让我们先回顾一下基于 auto 语法的泛型 lambda ，以及其局限性，然后再看 C++20 新增的基于模板的泛型 lambda 。(C++14)基于 auto 的泛型 lambdaC++14 中的泛型 lambda ，是使用 ...

C++ 20新特性之Lambda优化

hope_wisdom的技术博客

06-11

631

自从C++ 11标准引入Lambda表达式以来，它已经成为现代C++编程中不可或缺的一部分，极大方便了我们的开发工作，提升了效率。而C++ 20对Lambda表达式的进一步优化和扩展，更是增强了其灵活性和实用性。

C++20学习笔记——头等函数（Lambda闭包）

XXTongC的博客

06-07

513

上述代码定义了一个函数指针，它可以储存参数为long和int、返回值为long的函数地址。但要注意的是不能将包括了fun_ptr的圆括号去掉，如果去掉该语句将被解释为返回long指针类型的函数。这样，我们就可以将fun_ptr指向任何与type_name拥有一样类型的参数与返回类型的函数了。以下写法与上述效果等效；故而很多人建议始终添加取址运算符，因为这样能够增加代码的可读性。double[ ]() {很奇怪是吧，我们同时使用了三种数学上的括号。

C++中的Lambda表达式详解

天涯路的专栏

08-07

449

一直都在提醒自己，我是搞C++的；但是当C++11出来这么长时间了，我却没有跟着队伍走，发现很对不起自己的身份，也还好，发现自己也有段时间没有写C++代码了。今天看到了C++中的Lambda表达式，虽然用过C#的，但是C++的，一直没有用，也不知道怎么用，就可怜的连Lambda语法都看不懂。好了，这里就对C++中的Lambda进行一个简单的总结，就算是对自己的一个交代，我是搞C++的，我是一个C++ programmer。一段简单的Code 我也不是文艺的人，对于Lambda的历史，以及Lambda与

Lambda表达式传入形参和实参C++

09-20

<think> 我们正在讨论C++中的Lambda表达式如何传递形参和实参。根据引用[1]和[2]提供的背景，我们知道Lambda表达式是C++11引入的匿名函数，可以方便地创建函数对象。引用[3]则涉及了Lambda表达式中的参数传递和完美转发(forward)技术。在C++中，Lambda表达式的形参列表定义在方括号[]之后的圆括号()内，而实参则在调用时传递。具体步骤： 1. Lambda表达式的基本语法： [capture](parameters) mutable -> return-type { body } 2. 形参(parameters)： - 类似于普通函数的形参，用于定义函数调用时需要传递的参数。 - 可以指定默认参数（C++14起支持）。 - 可以使用auto作为参数类型（C++14起），形成泛型Lambda。 3. 实参(arguments)： - 在调用Lambda表达式时，需要传递与形参类型和数量匹配的实参。 - 可以传递左值、右值，也可以通过引用传递。 4. 值捕获和引用捕获（与形参无关，但影响Lambda内部对捕获变量的使用）： - [=]：以值捕获所有外部变量 - [&]：以引用捕获所有外部变量 - 也可以显式指定捕获的变量，如[a, &b] 5. 完美转发： - 引用[3]提到，如果需要在Lambda表达式中保持参数的左值/右值属性，可以使用std::forward进行完美转发。 - 需要将Lambda表达式定义为可变(mutable)，并且使用auto&&或模板参数（C++20起支持显式模板参数）来接收参数。示例代码：示例1：基本参数传递 ```cpp #include <iostream> int main() { // 定义一个Lambda，接受两个int参数 auto add = [](int a, int b) -> int { return a + b; }; std::cout << add(3, 4) << std::endl; // 输出7，传递实参3和4 } ``` 示例2：使用默认参数（C++14起） ```cpp #include <iostream> int main() { // 默认参数为5 auto multiply = [](int a, int b = 5) -> int { return a * b; }; std::cout << multiply(3) << std::endl; // 输出15 (3*5) std::cout << multiply(3, 10) << std::endl; // 输出30 (3*10) } ``` 示例3：使用auto参数（C++14起，泛型Lambda） ```cpp #include <iostream> int main() { // 使用auto参数，可以接受不同类型的参数 auto print = [](auto value) { std::cout << value << std::endl; }; print(42); // 整数 print(3.14); // 浮点数 print("Hello"); // 字符串 } ``` 示例4：完美转发（保持参数的值类别）引用[3]中提到了forward的用法，在Lambda中实现完美转发需要将Lambda定义为可变(mutable)并使用auto&&（通用引用）： ```cpp #include <iostream> #include <utility> void process(int& x) { std::cout << "lvalue: " << x << std::endl; } void process(int&& x) { std::cout << "rvalue: " << x << std::endl; } int main() { auto wrapper = [](auto&& arg) { process(std::forward<decltype(arg)>(arg)); }; int x = 42; wrapper(x); // 传递左值，输出 lvalue: 42 wrapper(123); // 传递右值，输出 rvalue: 123 return 0; } ``` 注意：这里使用了`auto&&`来捕获参数，这样arg可以成为通用引用（既能绑定左值也能绑定右值）。然后使用`std::forward<decltype(arg)>`来转发参数，保持其原始的值类别。关于捕获列表： - 捕获列表用于捕获外部变量，使得Lambda内部可以使用这些变量。 - 捕获方式分为值捕获和引用捕获。 - 捕获和参数传递是两个不同的机制：捕获是在创建Lambda时捕获外部变量，而参数传递是在调用Lambda时传递实参。示例5：捕获与参数结合 ```cpp #include <iostream> int main() { int base = 100; // 值捕获base，并接受一个int参数 auto add_base = [base](int x) -> int { return base + x; }; std::cout << add_base(5) << std::endl; // 输出105 // 引用捕获base auto add_base_ref = [&base](int x) -> int { base += x; return base; }; std::cout << add_base_ref(5) << std::endl; // 输出105（base变为105） std::cout << base << std::endl; // 输出105，因为引用捕获改变了base的值 } ``` 注意事项： 1. 在Lambda表达式中，如果使用引用捕获，需要注意被引用变量的生命周期，避免悬垂引用。 2. 默认情况下，Lambda表达式是一个const函数对象，即不能修改值捕获的变量（除非使用mutable关键字）。 3. 完美转发在泛型Lambda中非常有用，尤其是在编写转发函数时（如包装器）。引用[4]提到了实参类型（位置参数和关键字参数）的概念，但在C++中并不区分位置参数和关键字参数，因为C++函数调用严格依赖参数位置和类型。在Lambda表达式中，参数传递同样遵循位置顺序。总结： - 形参：在Lambda的括号()内声明，指定类型（或使用auto）和可选的默认值。 - 实参：调用Lambda时提供，必须与形参的数量和类型兼容（考虑隐式转换）。因此，在C++中，Lambda表达式的参数传递机制与普通函数基本相同，同时还可以结合捕获列表来使用外部变量。相关问题： 1. C++ Lambda表达式如何捕获外部变量？值捕获和引用捕获有什么区别？ 2. 在C++ Lambda表达式中使用mutable关键字的作用是什么？ 3. 如何实现Lambda表达式的递归调用？ 4. C++14和C++20对Lambda表达式有哪些改进？ </think> ### C++ Lambda表达式参数传递详解在C++中，Lambda表达式的参数传递机制融合了函数参数传递的特性（形参与实参）和独特的捕获机制。以下是关键概念解析： #### 1. **形参声明与实参传递** Lambda表达式的参数列表定义在`(...)`中，与普通函数类似： ```cpp auto lambda = [](int a, double b) { return a * b; }; // a,b是形参 auto result = lambda(5, 3.14); // 5,3.14是实参 ``` - **位置传递**：实参按声明顺序绑定到形参[^4] - **类型匹配**：要求实参与形参类型兼容（支持隐式转换） - **默认参数**（C++14起支持）： ```cpp auto greet = [](string name = "Guest") { cout << "Hello, " << name; }; greet(); // 输出 "Hello, Guest" ``` #### 2. **捕获列表 vs 形参列表** Lambda特有捕获机制（`[]`内）与参数列表（`()`内）的区别： | 特性 | 捕获列表 `[]` | 形参列表 `()` | |--------------|---------------------|---------------------| | 绑定时机 | Lambda创建时 | Lambda调用时 | | 访问范围 | 外部作用域变量 | 调用时传入的值 | | 传递方式 | 值捕获/引用捕获 | 值/引用传递 | | 生命周期影响 | 影响被捕获变量 | 不影响外部实参 | 示例： ```cpp int base = 10; // 捕获base（值捕获），形参x auto adder = [base](int x) { return base + x; }; cout << adder(5); // 输出15（base=10, x=5） ``` #### 3. **值传递与引用传递** - **值传递**（默认）： ```cpp auto func = [](int a) { a *= 2; }; int x = 5; func(x); // x仍为5（形参a是副本） ``` - **引用传递**： ```cpp auto modifier = [](int& a) { a *= 2; }; int y = 5; modifier(y); // y变为10（修改原值） ``` #### 4. **完美转发（Perfect Forwarding）** 使用`auto&&`和`std::forward`保持值类别（左值/右值）[^3]： ```cpp auto wrapper = [](auto&& arg) { process(std::forward<decltype(arg)>(arg)); }; wrapper(42); // 转发右值 int z = 10; wrapper(z); // 转发左值 ``` 关键点： 1. `auto&&` 生成转发引用 2. `decltype(arg)` 获取原始类型 3. `std::forward` 保持值类别 #### 5. **泛型Lambda（C++14+）** 使用`auto`形参实现泛型： ```cpp auto generic = [](auto a, auto b) { return a + b; }; cout << generic(3, 4.2); // 输出7.2（int+double） ``` #### 6. **可变Lambda（mutable）** 默认Lambda为`const`，需`mutable`修改值捕获的副本： ```cpp int counter = 0; auto counter_func = [counter]() mutable { counter++; // 无mutable会编译错误 return counter; }; ``` ### 关键差异总结 1. **捕获列表**定义Lambda创建时的环境访问权限 2. **形参列表**定义Lambda调用时的输入接口 3. 两者可组合使用，例如同时捕获外部变量并接受调用参数： ```cpp double tax_rate = 0.2; auto calc_tax = [tax_rate](double income) { return income * tax_rate; }; ```