Lambda表达式如何解决修改外部变量的难题？

2026-04-29 07:542阅读0评论SEO问题
  • 内容介绍
  • 文章标签
  • 相关推荐

本文共计4099个文字，预计阅读时间需要17分钟。

Lambda表达式如何解决修改外部变量的难题？

首先，了解Lambda表达式及其外部变量修改问题。由于平台使用的是JDK8，虽然Lambda表达式提供了许多新特性，但可能对一些新特性还不够熟悉。以下是对Lambda表达式中外部变量修改问题的改进示例：

在Lambda表达式中修改外部变量可能存在线程安全问题，因为Lambda表达式内部捕获的外部变量在其生命周期内是可变的。以下是一个示例：

javapublic class Main { public static void main(String[] args) { int externalVar=10; Runnable task=() -> { externalVar +=5; // 修改外部变量 System.out.println(externalVar); }; new Thread(task).start(); }}

在这个例子中，Lambda表达式内的`externalVar`是外部变量。当Lambda表达式中的代码执行时，它修改了`externalVar`的值。由于Lambda表达式可能在不同的线程中执行，直接修改外部变量可能会导致线程安全问题。

为了避免这种问题，可以使用以下方法：

1. 使用局部变量替换外部变量：javaRunnable task=() -> { int localVar=externalVar + 5; // 使用局部变量 System.out.println(localVar);};

2. 使用`final`关键字：javafinal int finalVar=10;Runnable task=() -> { finalVar +=5; // 使用final变量 System.out.println(finalVar);};

通过这些方法，可以避免在Lambda表达式中直接修改外部变量，从而确保线程安全。

先看下Lambda表达式里面修改外部变量问题

因为平台用的是JDK8，而且发现自己对那些新特性好像一点都不了解，就例如Lambda表达式，所以就开始对自己的代码进行改进了。。。

例如遍历Map，像我们正常遍历肯定是下面这样子的。

String result = "select * from where id = '#userId#' and name = '#userName#'"; Map<String,String> sysParams = new HashMap<String,String>(); sysParams.put("#userId#", "userId"); sysParams.put("#userName#", "userName"); sysParams.put("#realName#", "realName"); sysParams.put("#orgIds#", "orgIds"); sysParams.put("#departname#", "departname"); sysParams.put("#roleId#", "roleId"); for(Map.Entry<String, String> entry : sysParams.entrySet()){ if(result .contains(entry.getKey())){ result = result .replaceAll(entry.getKey(), AppDataUtils.replaceSysData(entry.getValue())); } }

但是如果用Lambda表达式呢，将会非常的简单，

但是我们会发现，result那里是会报错的：Local variable result defined in an enclosing scope must be final or effectively final

String result = "select * from where id = '#userId#' and name = '#userName#'"; Map<String,String> sysParams = new HashMap<String,String>(); sysParams.put("#userId#", "userId"); sysParams.put("#userName#", "userName"); sysParams.put("#realName#", "realName"); sysParams.put("#orgIds#", "orgIds"); sysParams.put("#departname#", "departname"); sysParams.put("#roleId#", "roleId"); sysParams.forEach((key,value)->{ if(result.contains(key)){ result = result.replaceAll(key, value); } });

这是因为：Java会将result的值作为参数传递给Lambda表达式，为Lambda表达式建立一个副本，它的代码访问的是这个副本，而不是外部声明result变量。可能很多同学会问为什么非要建立副本呢，直接访问外部的result变量得多方便呢。答案是：这是不可能滴，因为result定义在栈中，当Lambda表达式被执行的时候，result可能已经被释放掉了。

当然啦，你要是一定要在Lambda表达式里面修改外部变量的值也是可以的，可以将变量定义为实例变量或者将变量定义为数组。

下面我就改为数组咯，实例变量不方便。

String result = "select * from where id = '#userId#' and name = '#userName#'"; //将变量定义为数组就好了 String[] arr = new String[]{result}; Map<String,String> sysParams = new HashMap<String,String>(); sysParams.put("#userId#", "userId"); sysParams.put("#userName#", "userName"); sysParams.put("#realName#", "realName"); sysParams.put("#orgIds#", "orgIds"); sysParams.put("#departname#", "departname"); sysParams.put("#roleId#", "roleId"); sysParams.forEach((key,value)->{ if(arr[0].contains(key)){ //都是对数组进行操作了 arr[0] = arr[0].replaceAll(key, value); } });

下面看下C++ lambda 捕获模式与右值引用详解

lambda 表达式和右值引用是 C++11 的两个非常有用的特性。

lambda 表达式实际上会由编译器创建一个std::function 对象，以值的方式捕获的变量则会由编译器复制一份，在std::function 对象中创建一个对应的类型相同的 const 成员变量，如下面的这段代码：

int main(){ std::string str = "test"; printf("String address %p in main, str %s\n", &str, str.c_str()); auto funca = [str]() { printf("String address %p (main lambda), str %s\n", &str, str.c_str()); }; std::function<void()> funcb = funca; std::function<void()> funcc; funcc = funca; printf("funca\n"); funca(); std::function<void()> funcd = std::move(funca); printf("funca\n"); funca(); printf("funcb\n"); funcb(); std::function<void()> funce; funce = std::move(funcb); printf("funcb\n"); // funcb(); printf("funcc\n"); funcc(); printf("funcd\n"); funcd(); printf("funce\n"); funce(); // std::function<void(int)> funcf = funce; return 0; }

这段代码的输出如下：

Stringaddress0x7ffd9aaab720 in main, strtest
funca
Stringaddress0x7ffd9aaab740 (main lambda), strtest
funca
Stringaddress0x7ffd9aaab740 (main lambda), str
funcb
Stringaddress0x55bdd2160280 (main lambda), strtest
funcb
funcc
Stringaddress0x55bdd21602b0 (main lambda), strtest
funcd
Stringaddress0x55bdd21602e0 (main lambda), strtest
funce
Stringaddress0x55bdd2160280 (main lambda), strtest

由上面调用funca 时的输出，可以看到 lambda 表达式以值的方式捕获的对象 str，其地址在 lambda 表达式内部和外部是不同的。

std::function 类对象和普通的魔板类对象一样，可以拷贝构造，如：

std::function<void()> funcb = funca;

由调用funcb 时的输出，可以看到拷贝构造时是做了逐成员的拷贝构造。

std::function 类对象可以赋值，如：

std::function<void()> funcc;
funcc = funca;

由调用funcc 时的输出，可以看到赋值时是做了逐成员的赋值。

std::function 类对象可以移动构造，如：

std::function<void()> funcd = std::move(funca);

由移动构造之后，调用funca 和funcd 时的输出，可以看到移动构造时是做了逐成员的移动构造。

std::function 类对象可以移动赋值，如：

std::function<void()> funce; funce = std::move(funcb); printf("funcb\n"); // funcb();

这里把移动赋值之后对funcb 的调用注释掉了，这是因为，作为源的funcb 在移动赋值之后被调用是，会抛出异常，如：

String address 0x562334c34280 (main lambda), str test funcb terminate called after throwing aninstanceof 'std::bad_function_call' what(): bad_function_call

同时，由调用funce 时的输出可以看到，该输出与funcb 在移动赋值之前被调用时的输出完全相同。即移动赋值是将对象整体 move 走了，这与移动构造时的行为不太一样。

std::function 类对象的拷贝构造或者赋值，也需要满足类型匹配原则，如：

std::function<void(int)> funcf = funce;

这行代码会造成编译失败，编译错误信息如下：

../src/DemoTest.cpp: In function ‘intmain()':
../src/DemoTest.cpp:64:36: error: conversion from ‘std::function<void()>' to non-scalar type ‘std::function<void(int)>' requested
std::function<void(int)> funcf = funce;
^~~~~
make: *** [src/DemoTest.o] Error 1
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed

Lambda表达式如何解决修改外部变量的难题？

在 lambda 中以值的方式捕获的右值对象，只是在 lambda 的 std::function 对象中做了一份被捕获的右值对象的拷贝，而原来的右值则没有任何改变。

接下来再来看一段示例代码：

#include<iostream> #include<functional> #include<string> using namespace std; void funcd(std::string&&str){ printf("String address %p in funcd A, str %s\n", &str, str.c_str()); string strs = std::move(str); printf("String address %p in funcd B, str %s, strs %s\n", &str, str.c_str(), strs.c_str()); } void funcc(std::stringstr){ printf("String address %p in funcc, str %s\n", &str, str.c_str()); } void funcb(std::string&str){ printf("String address %p in funcb, str %s\n", &str, str.c_str()); } void funca(std::string&&str){ printf("String address %p in funca A, str %s\n", &str, str.c_str()); std::string stra = str; printf("String address %p in funca B, str %s, stra %s\n", &str, str.c_str(), stra.c_str()); } int main(){ std::string str = "test"; printf("String address %p in main A, str %s\n", &str, str.c_str()); funca(std::move(str)); printf("String address %p in main B, str %s\n", &str, str.c_str()); // funcb(std::move(str)); printf("String address %p in main C, str %s\n", &str, str.c_str()); funcc(std::move(str)); printf("String address %p in main D, str %s\n", &str, str.c_str()); std::string stra = "testa"; printf("String address %p in main E, stra %s\n", &stra, stra.c_str()); funcd(std::move(stra)); printf("String address %p in main F, stra %s\n", &stra, stra.c_str()); return 0; }

上面这段代码在执行时，输出如下：

String address 0x7ffc833f4660 in main A, str test
String address 0x7ffc833f4660 in funca A, str test
String address 0x7ffc833f4660 in funca B, str test, stra test
String address 0x7ffc833f4660 in main B, str test
String address 0x7ffc833f4660 in main C, str test
String address 0x7ffc833f4680 in funcc, str test
String address 0x7ffc833f4660 in main D, str
String address 0x7ffc833f4680 in main E, stra testa
String address 0x7ffc833f4680 in funcd A, str testa
String address 0x7ffc833f4680 in funcd B, str , strs testa
String address 0x7ffc833f4680 in main F, stra

funca 函数接收右值引用作为参数，由funca 函数内部及函数调用前后的输出可以看到，std::move() 本身什么都没做，单单调用std::move() 并不会将原来的对象的内容移动到任何地方。std::move() 只是一个简单的强制类型转换，将左值转为右值引用。同时可以看到，用右值引用作为参数构造对象，也并没有对右值引用所引用的对象产生任何影响。

funcb 函数接收左值引用作为参数，上面的代码中，如下这一行注释掉了：

// funcb(std::move(str));

这是因为，funcb 不能用一个右值引用作为参数来调用。用右值引用作为参数，调用接收左值引用作为参数的函数funcb 时，会编译失败：

g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In function ‘int main()':
../src/DemoTest.cpp:34:18: error: cannot bind non-const lvalue reference of type ‘std::__cxx11::string& {aka std::__cxx11::basic_string<char>&}' to an rvalue of type ‘std::remove_reference<std::__cxx11::basic_string<char>&>::type {aka std::__cxx11::basic_string<char>}'
funcb(std::move(str));
~~~~~~~~~^~~~~
../src/DemoTest.cpp:17:6: note: initializing argument 1 of ‘void funcb(std::__cxx11::string&)'
void funcb(std::string &str) {
^~~~~
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed
make: *** [src/DemoTest.o] Error 1

不过，如果funcb 接收 const 左值引用作为参数，如void funcb(const std::string &str) ，则在调用该函数时，可以用右值引用作为参数，此时funcb 的行为与funca 基本相同。

funcc 函数接收左值作为参数，由funcc 函数内部及函数调用前后的输出可以看到，由于有了左值作为接收者，传入的右值引用所引用的对象的值被 move 走，进入函数的参数栈对象中了。

funcd 函数与funca 函数一样，接收右值引用作为参数，但funcd 的特别之处在于，在函数内部，右值构造了一个新的对象，因而右值引用原来引用的对象的值被 move 走，进入了新构造的对象中。

再来看一段示例代码：

#include<iostream> #include<functional> #include<string> using namespace std; void bar(std::string&&str){ printf("String address %p in bar A, str %s\n", &str, str.c_str()); string strs = std::move(str); printf("String address %p in bar B, str %s, strs %s\n", &str, str.c_str(), strs.c_str()); } std::function<void()> bar_bar(std::string &&str) { auto funf = [&str]() { printf("String address %p (foo lambda) F, stra %s\n", &str, str.c_str()); }; return funf; } std::function<void()> foo(std::string &&str) { printf("String address %p in foo A, str %s\n", &str, str.c_str()); // auto funa = [str]() { // printf("String address %p (foo lambda) A, str %s\n", &str, str.c_str()); // bar(str); // }; // funa(); // // auto funb = [str]() { // printf("String address %p (foo lambda) B, str %s\n", &str, str.c_str()); // bar(std::move(str)); // }; // funb(); // auto func = [str]() mutable { // printf("String address %p (foo lambda) C, str %s\n", &str, str.c_str()); // bar(str); // }; // func(); auto fund = [str]() mutable { printf("String address %p (foo lambda) D, str %s\n", &str, str.c_str()); bar(std::move(str)); }; fund(); auto fune = [&str]() { printf("String address %p (foo lambda) E, str %s\n", &str, str.c_str()); bar(std::move(str)); }; fune(); std::string stra = "testa"; return bar_bar(std::move(stra)); } int main(){ std::string str = "test"; printf("String address %p in main A, str %s\n", &str, str.c_str()); auto funcg = foo(std::move(str)); printf("String address %p in main B, str %s\n", &str, str.c_str()); funcg(); return 0; }

上面这段代码的输出如下：

Stringaddress0x7ffc9fe7c5c0 in main A, strtest
Stringaddress0x7ffc9fe7c5c0 in foo A, strtest
Stringaddress0x7ffc9fe7c540 (foo lambda) D, strtest
Stringaddress0x7ffc9fe7c540 in barA, strtest
Stringaddress0x7ffc9fe7c540 in barB,str, strstest
Stringaddress0x7ffc9fe7c5c0 (foo lambda) E, strtest
Stringaddress0x7ffc9fe7c5c0 in barA, strtest
Stringaddress0x7ffc9fe7c5c0 in barB,str, strstest
Stringaddress0x7ffc9fe7c5c0 in main B,str
Stringaddress0x7ffc9fe7c560 (foo lambda) F, stra����

在函数foo() 中定义的funa 及对funa 的调用被注释掉了，这是因为这段代码会导致编译失败，具体的错误信息如下：

Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In lambda function:
../src/DemoTest.cpp:25:12: error: cannot bind rvalue reference of type ‘std::__cxx11::string&& {aka std::__cxx11::basic_string<char>&&}' to lvalue of type ‘const string {aka const std::__cxx11::basic_string<char>}'
bar(str);
^
../src/DemoTest.cpp:7:6: note: initializing argument 1 of ‘void bar(std::__cxx11::string&&)'
void bar(std::string &&str) {
^~~
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed
make: *** [src/DemoTest.o] Error 1

如我们前面提到的，在 lambda 表达式中，以值的方式捕获右值引用时，会在编译器为该 lambda 表达式生成的std::function 类中生成一个 const 对象，const 对象是不能作为右值引用来调用接收右值引用为参数的函数的。

在函数foo() 中定义的funb ，相对于funa ，在调用bar() 时，为str 裹上了std::move() 。不过此时还是会编译失败。错误信息如下：

Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In lambda function:
../src/DemoTest.cpp:31:18: error: binding reference of type ‘std::__cxx11::string&& {aka std::__cxx11::basic_string<char>&&}' to ‘std::remove_reference<const std::__cxx11::basic_string<char>&>::type {aka const std::__cxx11::basic_string<char>}' discards qualifiers
bar(std::move(str));
~~~~~~~~~^~~~~
../src/DemoTest.cpp:7:6: note: initializing argument 1 of ‘void bar(std::__cxx11::string&&)'
void bar(std::string &&str) {
^~~
make: *** [src/DemoTest.o] Error 1
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed

在funb 中，str 是个 const 对象，因而还是不行。

在函数foo() 中定义的func ，相对于funa ，加了mutable 修饰。此时还是会编译失败。错误信息如下：

Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In lambda function:
../src/DemoTest.cpp:37:12: error: cannot bind rvalue reference of type ‘std::__cxx11::string&& {aka std::__cxx11::basic_string<char>&&}' to lvalue of type ‘std::__cxx11::string {aka std::__cxx11::basic_string<char>}'
bar(str);
^
../src/DemoTest.cpp:7:6: note: initializing argument 1 of ‘void bar(std::__cxx11::string&&)'
void bar(std::string &&str) {
^~~
make: *** [src/DemoTest.o] Error 1
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed

无法将左值绑定到一个右值引用上。

在函数foo() 中定义的fund ，相对于func ，在调用bar() 时，为str 裹上了std::move() 。此时终于可以编译成功，可以 move const 的str 。

在函数foo() 中定义的fune ，相对于funb ，以引用的方式捕获了右值引用。在fune 中调用bar() ，就如同foo() 直接调用bar() 一样。

在函数foo() 中调用接收一个右值引用作为参数的函数bar_bar() 生成一个函数。在函数bar_bar() 中用 lambda 定义的函数对象funf ，以引用的方式捕获一个右值，并在 lambda 中访问改对象。该 lambda 作为bar_bar() 函数生成的函数对象。foo() 中调用bar_bar() 时传入函数栈上定义的临时对象stra ，并将bar_bar() 返回的函数对象作为返回值返回。在main() 函数中用funcg 接收foo() 函数返回的函数对象，并调用funcg ，此时会发生 crash 或能看到乱码。crash 或乱码是因为，在 funf 中，访问的str 对象实际上是foo() 函数中定义的栈上临时对象stra ，foo() 函数调用结束之后，栈上的临时对象被释放，main() 函数中调用funcg 实际在访问一个无效的对象，因而出现问题。

总结

到此这篇关于Lambda表达式里面修改外部变量问题的文章就介绍到这了,更多相关C++ lambda 表达式内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！

标签：lambda表达式里面修改外部

相关推荐

128181Gemini 出 Mac 应用了128182双日凌空 neo压力山大128183【开源】可能是最好看的 openclaw 替代终于发布 0.1.0 版本啦！（功能也超级全）128188人怎么能活得这么失败128192【开源】AgentMux 避免claude -p定时任务频繁429限流128194发个win平台vscode codex插件补丁，能有效减少warning刷屏的情况128201Linux系统重启及服务管理命令有哪些？128203【开源推广】SpineDigest：把长篇内容蒸馏成知识脊柱128207好消息xChat上线了，坏消息只有苹果的？128211Linux中如何将文件或文件夹复制到指定目录？128213gpt5.5 前端能力128216想问一下固态的价格，能不能入？128219GPT-5.5及GPT-5.5 Pro目前已可以通过API使用128221如何用newapi调用claude模型128225再次被 image-2惊艳了128226自建公益站过程记录，站在巨人的肩膀上，基于new-api，从服务器到域名到防护全流程教程

本文共计4099个文字，预计阅读时间需要17分钟。

Lambda表达式如何解决修改外部变量的难题？

首先，了解Lambda表达式及其外部变量修改问题。由于平台使用的是JDK8，虽然Lambda表达式提供了许多新特性，但可能对一些新特性还不够熟悉。以下是对Lambda表达式中外部变量修改问题的改进示例：

在Lambda表达式中修改外部变量可能存在线程安全问题，因为Lambda表达式内部捕获的外部变量在其生命周期内是可变的。以下是一个示例：

javapublic class Main { public static void main(String[] args) { int externalVar=10; Runnable task=() -> { externalVar +=5; // 修改外部变量 System.out.println(externalVar); }; new Thread(task).start(); }}

在这个例子中，Lambda表达式内的`externalVar`是外部变量。当Lambda表达式中的代码执行时，它修改了`externalVar`的值。由于Lambda表达式可能在不同的线程中执行，直接修改外部变量可能会导致线程安全问题。

为了避免这种问题，可以使用以下方法：

1. 使用局部变量替换外部变量：javaRunnable task=() -> { int localVar=externalVar + 5; // 使用局部变量 System.out.println(localVar);};

2. 使用`final`关键字：javafinal int finalVar=10;Runnable task=() -> { finalVar +=5; // 使用final变量 System.out.println(finalVar);};

通过这些方法，可以避免在Lambda表达式中直接修改外部变量，从而确保线程安全。

先看下Lambda表达式里面修改外部变量问题

因为平台用的是JDK8，而且发现自己对那些新特性好像一点都不了解，就例如Lambda表达式，所以就开始对自己的代码进行改进了。。。

例如遍历Map，像我们正常遍历肯定是下面这样子的。

String result = "select * from where id = '#userId#' and name = '#userName#'"; Map<String,String> sysParams = new HashMap<String,String>(); sysParams.put("#userId#", "userId"); sysParams.put("#userName#", "userName"); sysParams.put("#realName#", "realName"); sysParams.put("#orgIds#", "orgIds"); sysParams.put("#departname#", "departname"); sysParams.put("#roleId#", "roleId"); for(Map.Entry<String, String> entry : sysParams.entrySet()){ if(result .contains(entry.getKey())){ result = result .replaceAll(entry.getKey(), AppDataUtils.replaceSysData(entry.getValue())); } }

但是如果用Lambda表达式呢，将会非常的简单，

但是我们会发现，result那里是会报错的：Local variable result defined in an enclosing scope must be final or effectively final

String result = "select * from where id = '#userId#' and name = '#userName#'"; Map<String,String> sysParams = new HashMap<String,String>(); sysParams.put("#userId#", "userId"); sysParams.put("#userName#", "userName"); sysParams.put("#realName#", "realName"); sysParams.put("#orgIds#", "orgIds"); sysParams.put("#departname#", "departname"); sysParams.put("#roleId#", "roleId"); sysParams.forEach((key,value)->{ if(result.contains(key)){ result = result.replaceAll(key, value); } });

这是因为：Java会将result的值作为参数传递给Lambda表达式，为Lambda表达式建立一个副本，它的代码访问的是这个副本，而不是外部声明result变量。可能很多同学会问为什么非要建立副本呢，直接访问外部的result变量得多方便呢。答案是：这是不可能滴，因为result定义在栈中，当Lambda表达式被执行的时候，result可能已经被释放掉了。

当然啦，你要是一定要在Lambda表达式里面修改外部变量的值也是可以的，可以将变量定义为实例变量或者将变量定义为数组。

下面我就改为数组咯，实例变量不方便。

String result = "select * from where id = '#userId#' and name = '#userName#'"; //将变量定义为数组就好了 String[] arr = new String[]{result}; Map<String,String> sysParams = new HashMap<String,String>(); sysParams.put("#userId#", "userId"); sysParams.put("#userName#", "userName"); sysParams.put("#realName#", "realName"); sysParams.put("#orgIds#", "orgIds"); sysParams.put("#departname#", "departname"); sysParams.put("#roleId#", "roleId"); sysParams.forEach((key,value)->{ if(arr[0].contains(key)){ //都是对数组进行操作了 arr[0] = arr[0].replaceAll(key, value); } });

下面看下C++ lambda 捕获模式与右值引用详解

lambda 表达式和右值引用是 C++11 的两个非常有用的特性。

lambda 表达式实际上会由编译器创建一个std::function 对象，以值的方式捕获的变量则会由编译器复制一份，在std::function 对象中创建一个对应的类型相同的 const 成员变量，如下面的这段代码：

int main(){ std::string str = "test"; printf("String address %p in main, str %s\n", &str, str.c_str()); auto funca = [str]() { printf("String address %p (main lambda), str %s\n", &str, str.c_str()); }; std::function<void()> funcb = funca; std::function<void()> funcc; funcc = funca; printf("funca\n"); funca(); std::function<void()> funcd = std::move(funca); printf("funca\n"); funca(); printf("funcb\n"); funcb(); std::function<void()> funce; funce = std::move(funcb); printf("funcb\n"); // funcb(); printf("funcc\n"); funcc(); printf("funcd\n"); funcd(); printf("funce\n"); funce(); // std::function<void(int)> funcf = funce; return 0; }

这段代码的输出如下：

Stringaddress0x7ffd9aaab720 in main, strtest
funca
Stringaddress0x7ffd9aaab740 (main lambda), strtest
funca
Stringaddress0x7ffd9aaab740 (main lambda), str
funcb
Stringaddress0x55bdd2160280 (main lambda), strtest
funcb
funcc
Stringaddress0x55bdd21602b0 (main lambda), strtest
funcd
Stringaddress0x55bdd21602e0 (main lambda), strtest
funce
Stringaddress0x55bdd2160280 (main lambda), strtest

由上面调用funca 时的输出，可以看到 lambda 表达式以值的方式捕获的对象 str，其地址在 lambda 表达式内部和外部是不同的。

std::function 类对象和普通的魔板类对象一样，可以拷贝构造，如：

std::function<void()> funcb = funca;

由调用funcb 时的输出，可以看到拷贝构造时是做了逐成员的拷贝构造。

std::function 类对象可以赋值，如：

std::function<void()> funcc;
funcc = funca;

由调用funcc 时的输出，可以看到赋值时是做了逐成员的赋值。

std::function 类对象可以移动构造，如：

std::function<void()> funcd = std::move(funca);

由移动构造之后，调用funca 和funcd 时的输出，可以看到移动构造时是做了逐成员的移动构造。

std::function 类对象可以移动赋值，如：

std::function<void()> funce; funce = std::move(funcb); printf("funcb\n"); // funcb();

这里把移动赋值之后对funcb 的调用注释掉了，这是因为，作为源的funcb 在移动赋值之后被调用是，会抛出异常，如：

String address 0x562334c34280 (main lambda), str test funcb terminate called after throwing aninstanceof 'std::bad_function_call' what(): bad_function_call

同时，由调用funce 时的输出可以看到，该输出与funcb 在移动赋值之前被调用时的输出完全相同。即移动赋值是将对象整体 move 走了，这与移动构造时的行为不太一样。

std::function 类对象的拷贝构造或者赋值，也需要满足类型匹配原则，如：

std::function<void(int)> funcf = funce;

这行代码会造成编译失败，编译错误信息如下：

../src/DemoTest.cpp: In function ‘intmain()':
../src/DemoTest.cpp:64:36: error: conversion from ‘std::function<void()>' to non-scalar type ‘std::function<void(int)>' requested
std::function<void(int)> funcf = funce;
^~~~~
make: *** [src/DemoTest.o] Error 1
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed

Lambda表达式如何解决修改外部变量的难题？

在 lambda 中以值的方式捕获的右值对象，只是在 lambda 的 std::function 对象中做了一份被捕获的右值对象的拷贝，而原来的右值则没有任何改变。

接下来再来看一段示例代码：

#include<iostream> #include<functional> #include<string> using namespace std; void funcd(std::string&&str){ printf("String address %p in funcd A, str %s\n", &str, str.c_str()); string strs = std::move(str); printf("String address %p in funcd B, str %s, strs %s\n", &str, str.c_str(), strs.c_str()); } void funcc(std::stringstr){ printf("String address %p in funcc, str %s\n", &str, str.c_str()); } void funcb(std::string&str){ printf("String address %p in funcb, str %s\n", &str, str.c_str()); } void funca(std::string&&str){ printf("String address %p in funca A, str %s\n", &str, str.c_str()); std::string stra = str; printf("String address %p in funca B, str %s, stra %s\n", &str, str.c_str(), stra.c_str()); } int main(){ std::string str = "test"; printf("String address %p in main A, str %s\n", &str, str.c_str()); funca(std::move(str)); printf("String address %p in main B, str %s\n", &str, str.c_str()); // funcb(std::move(str)); printf("String address %p in main C, str %s\n", &str, str.c_str()); funcc(std::move(str)); printf("String address %p in main D, str %s\n", &str, str.c_str()); std::string stra = "testa"; printf("String address %p in main E, stra %s\n", &stra, stra.c_str()); funcd(std::move(stra)); printf("String address %p in main F, stra %s\n", &stra, stra.c_str()); return 0; }

上面这段代码在执行时，输出如下：

String address 0x7ffc833f4660 in main A, str test
String address 0x7ffc833f4660 in funca A, str test
String address 0x7ffc833f4660 in funca B, str test, stra test
String address 0x7ffc833f4660 in main B, str test
String address 0x7ffc833f4660 in main C, str test
String address 0x7ffc833f4680 in funcc, str test
String address 0x7ffc833f4660 in main D, str
String address 0x7ffc833f4680 in main E, stra testa
String address 0x7ffc833f4680 in funcd A, str testa
String address 0x7ffc833f4680 in funcd B, str , strs testa
String address 0x7ffc833f4680 in main F, stra

funca 函数接收右值引用作为参数，由funca 函数内部及函数调用前后的输出可以看到，std::move() 本身什么都没做，单单调用std::move() 并不会将原来的对象的内容移动到任何地方。std::move() 只是一个简单的强制类型转换，将左值转为右值引用。同时可以看到，用右值引用作为参数构造对象，也并没有对右值引用所引用的对象产生任何影响。

funcb 函数接收左值引用作为参数，上面的代码中，如下这一行注释掉了：

// funcb(std::move(str));

这是因为，funcb 不能用一个右值引用作为参数来调用。用右值引用作为参数，调用接收左值引用作为参数的函数funcb 时，会编译失败：

g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In function ‘int main()':
../src/DemoTest.cpp:34:18: error: cannot bind non-const lvalue reference of type ‘std::__cxx11::string& {aka std::__cxx11::basic_string<char>&}' to an rvalue of type ‘std::remove_reference<std::__cxx11::basic_string<char>&>::type {aka std::__cxx11::basic_string<char>}'
funcb(std::move(str));
~~~~~~~~~^~~~~
../src/DemoTest.cpp:17:6: note: initializing argument 1 of ‘void funcb(std::__cxx11::string&)'
void funcb(std::string &str) {
^~~~~
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed
make: *** [src/DemoTest.o] Error 1

不过，如果funcb 接收 const 左值引用作为参数，如void funcb(const std::string &str) ，则在调用该函数时，可以用右值引用作为参数，此时funcb 的行为与funca 基本相同。

funcc 函数接收左值作为参数，由funcc 函数内部及函数调用前后的输出可以看到，由于有了左值作为接收者，传入的右值引用所引用的对象的值被 move 走，进入函数的参数栈对象中了。

funcd 函数与funca 函数一样，接收右值引用作为参数，但funcd 的特别之处在于，在函数内部，右值构造了一个新的对象，因而右值引用原来引用的对象的值被 move 走，进入了新构造的对象中。

再来看一段示例代码：

#include<iostream> #include<functional> #include<string> using namespace std; void bar(std::string&&str){ printf("String address %p in bar A, str %s\n", &str, str.c_str()); string strs = std::move(str); printf("String address %p in bar B, str %s, strs %s\n", &str, str.c_str(), strs.c_str()); } std::function<void()> bar_bar(std::string &&str) { auto funf = [&str]() { printf("String address %p (foo lambda) F, stra %s\n", &str, str.c_str()); }; return funf; } std::function<void()> foo(std::string &&str) { printf("String address %p in foo A, str %s\n", &str, str.c_str()); // auto funa = [str]() { // printf("String address %p (foo lambda) A, str %s\n", &str, str.c_str()); // bar(str); // }; // funa(); // // auto funb = [str]() { // printf("String address %p (foo lambda) B, str %s\n", &str, str.c_str()); // bar(std::move(str)); // }; // funb(); // auto func = [str]() mutable { // printf("String address %p (foo lambda) C, str %s\n", &str, str.c_str()); // bar(str); // }; // func(); auto fund = [str]() mutable { printf("String address %p (foo lambda) D, str %s\n", &str, str.c_str()); bar(std::move(str)); }; fund(); auto fune = [&str]() { printf("String address %p (foo lambda) E, str %s\n", &str, str.c_str()); bar(std::move(str)); }; fune(); std::string stra = "testa"; return bar_bar(std::move(stra)); } int main(){ std::string str = "test"; printf("String address %p in main A, str %s\n", &str, str.c_str()); auto funcg = foo(std::move(str)); printf("String address %p in main B, str %s\n", &str, str.c_str()); funcg(); return 0; }

上面这段代码的输出如下：

Stringaddress0x7ffc9fe7c5c0 in main A, strtest
Stringaddress0x7ffc9fe7c5c0 in foo A, strtest
Stringaddress0x7ffc9fe7c540 (foo lambda) D, strtest
Stringaddress0x7ffc9fe7c540 in barA, strtest
Stringaddress0x7ffc9fe7c540 in barB,str, strstest
Stringaddress0x7ffc9fe7c5c0 (foo lambda) E, strtest
Stringaddress0x7ffc9fe7c5c0 in barA, strtest
Stringaddress0x7ffc9fe7c5c0 in barB,str, strstest
Stringaddress0x7ffc9fe7c5c0 in main B,str
Stringaddress0x7ffc9fe7c560 (foo lambda) F, stra����

在函数foo() 中定义的funa 及对funa 的调用被注释掉了，这是因为这段代码会导致编译失败，具体的错误信息如下：

Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In lambda function:
../src/DemoTest.cpp:25:12: error: cannot bind rvalue reference of type ‘std::__cxx11::string&& {aka std::__cxx11::basic_string<char>&&}' to lvalue of type ‘const string {aka const std::__cxx11::basic_string<char>}'
bar(str);
^
../src/DemoTest.cpp:7:6: note: initializing argument 1 of ‘void bar(std::__cxx11::string&&)'
void bar(std::string &&str) {
^~~
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed
make: *** [src/DemoTest.o] Error 1

如我们前面提到的，在 lambda 表达式中，以值的方式捕获右值引用时，会在编译器为该 lambda 表达式生成的std::function 类中生成一个 const 对象，const 对象是不能作为右值引用来调用接收右值引用为参数的函数的。

在函数foo() 中定义的funb ，相对于funa ，在调用bar() 时，为str 裹上了std::move() 。不过此时还是会编译失败。错误信息如下：

Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In lambda function:
../src/DemoTest.cpp:31:18: error: binding reference of type ‘std::__cxx11::string&& {aka std::__cxx11::basic_string<char>&&}' to ‘std::remove_reference<const std::__cxx11::basic_string<char>&>::type {aka const std::__cxx11::basic_string<char>}' discards qualifiers
bar(std::move(str));
~~~~~~~~~^~~~~
../src/DemoTest.cpp:7:6: note: initializing argument 1 of ‘void bar(std::__cxx11::string&&)'
void bar(std::string &&str) {
^~~
make: *** [src/DemoTest.o] Error 1
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed

在funb 中，str 是个 const 对象，因而还是不行。

在函数foo() 中定义的func ，相对于funa ，加了mutable 修饰。此时还是会编译失败。错误信息如下：

Invoking: GCC C++ Compiler
g++ -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/DemoTest.d" -MT"src/DemoTest.o" -o "src/DemoTest.o" "../src/DemoTest.cpp"
../src/DemoTest.cpp: In lambda function:
../src/DemoTest.cpp:37:12: error: cannot bind rvalue reference of type ‘std::__cxx11::string&& {aka std::__cxx11::basic_string<char>&&}' to lvalue of type ‘std::__cxx11::string {aka std::__cxx11::basic_string<char>}'
bar(str);
^
../src/DemoTest.cpp:7:6: note: initializing argument 1 of ‘void bar(std::__cxx11::string&&)'
void bar(std::string &&str) {
^~~
make: *** [src/DemoTest.o] Error 1
src/subdir.mk:18: recipe for target 'src/DemoTest.o' failed

无法将左值绑定到一个右值引用上。

在函数foo() 中定义的fund ，相对于func ，在调用bar() 时，为str 裹上了std::move() 。此时终于可以编译成功，可以 move const 的str 。

在函数foo() 中定义的fune ，相对于funb ，以引用的方式捕获了右值引用。在fune 中调用bar() ，就如同foo() 直接调用bar() 一样。

在函数foo() 中调用接收一个右值引用作为参数的函数bar_bar() 生成一个函数。在函数bar_bar() 中用 lambda 定义的函数对象funf ，以引用的方式捕获一个右值，并在 lambda 中访问改对象。该 lambda 作为bar_bar() 函数生成的函数对象。foo() 中调用bar_bar() 时传入函数栈上定义的临时对象stra ，并将bar_bar() 返回的函数对象作为返回值返回。在main() 函数中用funcg 接收foo() 函数返回的函数对象，并调用funcg ，此时会发生 crash 或能看到乱码。crash 或乱码是因为，在 funf 中，访问的str 对象实际上是foo() 函数中定义的栈上临时对象stra ，foo() 函数调用结束之后，栈上的临时对象被释放，main() 函数中调用funcg 实际在访问一个无效的对象，因而出现问题。

总结

到此这篇关于Lambda表达式里面修改外部变量问题的文章就介绍到这了,更多相关C++ lambda 表达式内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！