Вот как-то зашло мне последнее время лямбды повсюду пихать.
Но совершенно лень выписывать всякие капчи и прочие спеки, пишу [&] всегда.

int shift;

//... куча всякого хлама, который не обязательно капчить

f(something,[&](int i){return i-shift;},[&](int i){return i+shift});

f(something,[shift](int i){return i-shift;},[shift](int i){return i+shift});

Есть ли реальная разница между первым и вторым вариантом? Догадывается ли компилятор, какой именно контекст и как именно надо захватывать?


И вообще, умеет ли компилятор инлайнить лямбды?
Какая разница между следующими примерами? (Ну не считая, что во втором контекст можно передавать оптимальнее в зависимости от контекста)

Something* CreateSomething(std::function<void(std::function<void(Func*,cont int*)>)> cb)
{
    //... context
    cb([&](Func* func,const int* params){
        //...using context
        //Вычисляем сколько куда памяти выделять и все такое
    });
    //...
    cb([&](Func* func,const int* params){
        //...using context
        //Заполняем структуры
    });
}

//...
CreateSomething([&](std::function<void(Func*,const int* params)> cb_expr){
    //...
    cb_expr(func_m,params_m);
    //...
    cb_expr(func_n,params_n);
});

inline void Step0_OfCreatingSomething(void* contex,Func* func,const int* params)
{
    //...using context
    //Вычисляем сколько куда памяти выделять и все такое
}

inline void Step1_OfCreatingSomething(void* contex,Func* func,const int* params)
{
    //...using context
    //Заполняем структуры
}

Something* CreateSomething((void* cb)((void*)(void*,Func*,const int*)))
{
    //... context

    (*cb)(context,Step0_OfCreatingSomething);
    //...
    (*cb)(context,Step1_OfCreatingSomething);
    
}

void g(void* context,void(*cb_expr)(void* context,Func*,const int* params))
{
    //...
    (*cb_expr)(context,func_m,params_m);
    //...
    (*cb_expr)(context,func_n,params_n);
}

//...
CreateSomething(g);

Вот как-то зашло мне последнее время лямбды повсюду пихать.
Но совершенно лень выписывать всякие капчи и прочие спеки, пишу [&] всегда.

int shift;

//... куча всякого хлама, который не обязательно капчить

f(something,[&](int i){return i-shift;},[&](int i){return i+shift});

f(something,[shift](int i){return i-shift;},[shift](int i){return i+shift});

Есть ли реальная разница между первым и вторым вариантом? Догадывается ли компилятор, какой именно контекст и как именно надо захватывать?


И вообще, умеет ли компилятор инлайнить лямбды?
Какая разница между следующими примерами? (Ну не считая, что во втором контекст можно передавать оптимальнее в зависимости от контекста)

Something* CreateSomething(std::function<void(std::function<void(Func*,cont int*)>)> cb)
{
    //... context
    cb([&](Func* func,const int* params){
        //...using context
        //Вычисляем сколько куда памяти выделять и все такое
    });
    //...
    cb([&](Func* func,const int* params){
        //...using context
        //Заполняем структуры
    });
}

//...
CreateSomething([&](std::function<void(Func*,const int* params)> cb_expr){
    //...
    cb_expr(func_m,params_m);
    //...
    cb_expr(func_n,params_n);
});

inline void Step0_OfCreatingSomething(void* contex,Func* func,const int* params)
{
    //...using context
    //Вычисляем сколько куда памяти выделять и все такое
}

inline void Step1_OfCreatingSomething(void* contex,Func* func,const int* params)
{
    //...using context
    //Заполняем структуры
}

Something* CreateSomething((void* cb)((void*)(void*,Func*,const int*)))
{
    //... context

    (*cb)(context,Step0_OfCreatingSomething);
    //...
    (*cb)(context,Step1_OfCreatingSomething);
    
}

void g(void* context,void(*cb_expr)(void* context,Func*,const int* params))
{
    //...
    (*cb_expr)(context,func_m,params_m);
    //...
    (*cb_expr)(context,func_n,params_n);
}

//...
CreateSomething(g);

added: Упс, выдал желаемое за действительное. Какой нафиг inline во втором кейсе Ну вобщем собсно в этом-то и вопрос, умеет ли компилятор создавать там инлайны?
Ведь он же сам генерит функцию g, и соответственно может сгенерить разные варианты для первого и второго шага.