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

2023-07-28 05:09:13 64

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

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

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

Stringresult="select*fromwhereid='#userId#'andname='#userName#'";
MapsysParams=newHashMap();
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.Entryentry:sysParams.entrySet()){
if(result.contains(entry.getKey())){
result=result.replaceAll(entry.getKey(),AppDataUtils.replaceSysData(entry.getValue()));
}
}

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

但是我们会发现，result那里是会报错的：Localvariableresultdefinedinanenclosingscopemustbefinaloreffectivelyfinal

Stringresult="select*fromwhereid='#userId#'andname='#userName#'";
MapsysParams=newHashMap();
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表达式里面修改外部变量的值也是可以的，可以将变量定义为实例变量或者将变量定义为数组。

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

Stringresult="select*fromwhereid='#userId#'andname='#userName#'";
//将变量定义为数组就好了
String[]arr=newString[]{result};
MapsysParams=newHashMap();
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成员变量，如下面的这段代码：

intmain(){
std::stringstr="test";
printf("Stringaddress%pinmain,str%s\n",&str,str.c_str());
autofunca=[str](){
printf("Stringaddress%p(mainlambda),str%s\n",&str,str.c_str());
};
std::functionfuncb=funca;
std::functionfuncc;
funcc=funca;
printf("funca\n");
funca();
std::functionfuncd=std::move(funca);
printf("funca\n");
funca();
printf("funcb\n");
funcb();
std::functionfunce;
funce=std::move(funcb);
printf("funcb\n");
//funcb();
printf("funcc\n");
funcc();
printf("funcd\n");
funcd();
printf("funce\n");
funce();
//std::functionfuncf=funce;
return0;
}

这段代码的输出如下：

Stringaddress0x7ffd9aaab720inmain,strtest
funca
Stringaddress0x7ffd9aaab740(mainlambda),strtest
funca
Stringaddress0x7ffd9aaab740(mainlambda),str
funcb
Stringaddress0x55bdd2160280(mainlambda),strtest
funcb
funcc
Stringaddress0x55bdd21602b0(mainlambda),strtest
funcd
Stringaddress0x55bdd21602e0(mainlambda),strtest
funce
Stringaddress0x55bdd2160280(mainlambda),strtest

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

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

std::functionfuncb=funca;

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

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

std::functionfuncc;
funcc=funca;

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

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

std::functionfuncd=std::move(funca);

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

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

std::functionfunce;
funce=std::move(funcb);

printf("funcb\n");
//funcb();

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

Stringaddress0x562334c34280(mainlambda),strtest
funcb
terminatecalledafterthrowinganinstanceof'std::bad_function_call'
what():bad_function_call

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

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

std::functionfuncf=funce;

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

../src/DemoTest.cpp:Infunction‘intmain()':
../src/DemoTest.cpp:64:36:error:conversionfrom‘std::function'tonon-scalartype‘std::function'requested
std::functionfuncf=funce;
^~~~~
make:***[src/DemoTest.o]Error1
src/subdir.mk:18:recipefortarget'src/DemoTest.o'failed

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

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

#include
#include
#include

usingnamespacestd;

voidfuncd(std::string&&str){
printf("Stringaddress%pinfuncdA,str%s\n",&str,str.c_str());
stringstrs=std::move(str);
printf("Stringaddress%pinfuncdB,str%s,strs%s\n",&str,str.c_str(),strs.c_str());
}

voidfuncc(std::stringstr){
printf("Stringaddress%pinfuncc,str%s\n",&str,str.c_str());
}

voidfuncb(std::string&str){
printf("Stringaddress%pinfuncb,str%s\n",&str,str.c_str());
}

voidfunca(std::string&&str){
printf("Stringaddress%pinfuncaA,str%s\n",&str,str.c_str());
std::stringstra=str;
printf("Stringaddress%pinfuncaB,str%s,stra%s\n",&str,str.c_str(),stra.c_str());
}

intmain(){
std::stringstr="test";
printf("Stringaddress%pinmainA,str%s\n",&str,str.c_str());

funca(std::move(str));
printf("Stringaddress%pinmainB,str%s\n",&str,str.c_str());

//funcb(std::move(str));
printf("Stringaddress%pinmainC,str%s\n",&str,str.c_str());

funcc(std::move(str));
printf("Stringaddress%pinmainD,str%s\n",&str,str.c_str());

std::stringstra="testa";
printf("Stringaddress%pinmainE,stra%s\n",&stra,stra.c_str());

funcd(std::move(stra));
printf("Stringaddress%pinmainF,stra%s\n",&stra,stra.c_str());

return0;
}

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

Stringaddress0x7ffc833f4660inmainA,strtest
Stringaddress0x7ffc833f4660infuncaA,strtest
Stringaddress0x7ffc833f4660infuncaB,strtest,stratest
Stringaddress0x7ffc833f4660inmainB,strtest
Stringaddress0x7ffc833f4660inmainC,strtest
Stringaddress0x7ffc833f4680infuncc,strtest
Stringaddress0x7ffc833f4660inmainD,str
Stringaddress0x7ffc833f4680inmainE,stratesta
Stringaddress0x7ffc833f4680infuncdA,strtesta
Stringaddress0x7ffc833f4680infuncdB,str,strstesta
Stringaddress0x7ffc833f4680inmainF,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:Infunction‘intmain()':
../src/DemoTest.cpp:34:18:error:cannotbindnon-constlvaluereferenceoftype‘std::__cxx11::string&{akastd::__cxx11::basic_string&}'toanrvalueoftype‘std::remove_reference&>::type{akastd::__cxx11::basic_string}'
funcb(std::move(str));
~~~~~~~~~^~~~~
../src/DemoTest.cpp:17:6:note: initializingargument1of‘voidfuncb(std::__cxx11::string&)'
voidfuncb(std::string&str){
^~~~~
src/subdir.mk:18:recipefortarget'src/DemoTest.o'failed
make:***[src/DemoTest.o]Error1

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

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

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

再来看一段示例代码：

#include
#include
#include

usingnamespacestd;

voidbar(std::string&&str){
printf("Stringaddress%pinbarA,str%s\n",&str,str.c_str());
stringstrs=std::move(str);
printf("Stringaddress%pinbarB,str%s,strs%s\n",&str,str.c_str(),strs.c_str());
}

std::functionbar_bar(std::string&&str){
autofunf=[&str](){
printf("Stringaddress%p(foolambda)F,stra%s\n",&str,str.c_str());
};
returnfunf;
}

std::functionfoo(std::string&&str){
printf("Stringaddress%pinfooA,str%s\n",&str,str.c_str());

//autofuna=[str](){
//printf("Stringaddress%p(foolambda)A,str%s\n",&str,str.c_str());
//bar(str);
//};
//funa();
//
//autofunb=[str](){
//printf("Stringaddress%p(foolambda)B,str%s\n",&str,str.c_str());
//bar(std::move(str));
//};
//funb();

//autofunc=[str]()mutable{
//printf("Stringaddress%p(foolambda)C,str%s\n",&str,str.c_str());
//bar(str);
//};
//func();

autofund=[str]()mutable{
printf("Stringaddress%p(foolambda)D,str%s\n",&str,str.c_str());
bar(std::move(str));
};
fund();

autofune=[&str](){
printf("Stringaddress%p(foolambda)E,str%s\n",&str,str.c_str());
bar(std::move(str));
};
fune();

std::stringstra="testa";
returnbar_bar(std::move(stra));
}

intmain(){
std::stringstr="test";
printf("Stringaddress%pinmainA,str%s\n",&str,str.c_str());

autofuncg=foo(std::move(str));
printf("Stringaddress%pinmainB,str%s\n",&str,str.c_str());

funcg();

return0;
}

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

Stringaddress0x7ffc9fe7c5c0inmainA,strtest
Stringaddress0x7ffc9fe7c5c0infooA,strtest
Stringaddress0x7ffc9fe7c540(foolambda)D,strtest
Stringaddress0x7ffc9fe7c540inbarA,strtest
Stringaddress0x7ffc9fe7c540inbarB,str,strstest
Stringaddress0x7ffc9fe7c5c0(foolambda)E,strtest
Stringaddress0x7ffc9fe7c5c0inbarA,strtest
Stringaddress0x7ffc9fe7c5c0inbarB,str,strstest
Stringaddress0x7ffc9fe7c5c0inmainB,str
Stringaddress0x7ffc9fe7c560(foolambda)F,stra��

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

Invoking:GCCC++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:Inlambdafunction:
../src/DemoTest.cpp:25:12:error:cannotbindrvaluereferenceoftype‘std::__cxx11::string&&{akastd::__cxx11::basic_string&&}'tolvalueoftype‘conststring{akaconststd::__cxx11::basic_string}'
bar(str);
^
../src/DemoTest.cpp:7:6:note: initializingargument1of‘voidbar(std::__cxx11::string&&)'
voidbar(std::string&&str){
^~~
src/subdir.mk:18:recipefortarget'src/DemoTest.o'failed
make:***[src/DemoTest.o]Error1

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

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

Invoking:GCCC++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:Inlambdafunction:
../src/DemoTest.cpp:31:18:error:bindingreferenceoftype‘std::__cxx11::string&&{akastd::__cxx11::basic_string&&}'to‘std::remove_reference&>::type{akaconststd::__cxx11::basic_string}'discardsqualifiers
bar(std::move(str));
~~~~~~~~~^~~~~
../src/DemoTest.cpp:7:6:note: initializingargument1of‘voidbar(std::__cxx11::string&&)'
voidbar(std::string&&str){
^~~
make:***[src/DemoTest.o]Error1
src/subdir.mk:18:recipefortarget'src/DemoTest.o'failed

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

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

Invoking:GCCC++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:Inlambdafunction:
../src/DemoTest.cpp:37:12:error:cannotbindrvaluereferenceoftype‘std::__cxx11::string&&{akastd::__cxx11::basic_string&&}'tolvalueoftype‘std::__cxx11::string{akastd::__cxx11::basic_string}'
bar(str);
^
../src/DemoTest.cpp:7:6:note: initializingargument1of‘voidbar(std::__cxx11::string&&)'
voidbar(std::string&&str){
^~~
make:***[src/DemoTest.o]Error1
src/subdir.mk:18:recipefortarget'src/DemoTest.o'failed

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

在函数 foo()中定义的 fund，相对于 func，在调用 bar()时，为 str裹上了 std::move()。此时终于可以编译成功，可以moveconst的 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表达式里面修改外部变量问题

热门推荐

随机推荐