Question

我有一个我希望不止一次使用的lambda，但我希望它第二次在至少一个不同的（捕获）变量上运行。这种方法 - 使用在调用代码中重定向的lambda内的捕获指针ref到另一个变量 - 这是一种正常/明智的方法吗？或者我应该使用单独的机制，还是完全采用不同的方法？

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 );

Answer 1

功能风格的方法是使用闭包：

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));

Answer 2

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

选项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对象。你可以做到这几种方式。

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

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

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

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

pProcessor->ApplyLambdaOn( lambda, ms1 );

MyStruct ms2;
pProcessor->ApplyLambdaOn( lambda, ms2 );

这是在调用函数中重用C ++ 11 lambda的合理模式吗？

2 个答案:

选项1

选项2