这是在调用函数中重用 C++11 lambda 的明智模式吗?

Is this a sensible pattern for reusing a C++11 lambda within a calling function?

本文关键字：lambda 模式 C++11 调用 函数      更新时间：2023-10-16

我有一个 lambda，我希望它多次使用，但我希望它第二次至少对一个不同的(捕获(变量进行操作。这种方法 - 在调用代码中重定向到不同变量的 lambda 中使用捕获的指针引用 - 是一种正常/明智的方法吗？还是我应该使用单独的机制，或者完全使用不同的方法？

MyStruct ms1;
MyStruct* pActiveMyStruct = &ms1;
auto lambda = [&]( const Foo& foo, u32 index )
{
pActiveMyStruct->sScore = foo.m_Score;
pActiveMyStruct->DoSomethingWith( index );
};
pProcessor->ApplyLambdaOn( lambda );
MyStruct ms2;
pActiveMyStruct = &ms2;
pProcessor->ApplyLambdaOn( lambda );

函数式方法是使用闭包：

MyStruct ms1, ms2;
auto makeLambda = [](MyStruct& ms) {
return [&ms](const Foo& foo, u32 index) {
ms.sScore = foo.m_Score;
ms.DoSomethingWith(index);
};
};
pProcessor->ApplyLambdaOn(makeLambda(ms1));
pProcessor->ApplyLambdaOn(makeLambda(ms2));

我认为以下选项比使用对指针的引用更好。

选项 1

使用对MyStruct对象本身的引用，而不是对指针的引用。

MyStruct ms1;
auto lambda = [&ms1]( const Foo& foo, u32 index )
{
ms1.sScore = foo.m_Score;
ms1.DoSomethingWith( index );
};
pProcessor->ApplyLambdaOn( lambda );
MyStruct ms2;
ms1 = ms2;
pProcessor->ApplyLambdaOn( lambda );

选项 2

将MyStruct对象传递给 lambda 函数。

auto lambda = [&ms1]( const Foo& foo, u32 index, MyStruct& ms )
{
ms.sScore = foo.m_Score;
ms.DoSomethingWith( index );
};

为了能够做到这一点，pProcessor->ApplyLambdaOn必须有权访问MyStruct对象。你可以通过几种方式做到这一点。

  1. 将MyStruct对象存储在pProcessor中，并在ApplyLambdaOn的实现中使用它。

    pProcessor->setData(ms1);
pProcessor->ApplyLambdaOn( lambda );
MyStruct ms2;
pProcessor->setData(ms2);
pProcessor->ApplyLambdaOn( lambda );

  2. 将MyStruct对象作为另一个参数传递给ApplyLambdaOn。

    pProcessor->ApplyLambdaOn( lambda, ms1 );
MyStruct ms2;
pProcessor->ApplyLambdaOn( lambda, ms2 );
相关文章：