passing lambda as argument - by reference or value?

Question

I've written a template code that takes a functor as an argument and after some processing, executes it. Although someone else might pass that function a lambda, a function pointer or even an std::function but it is meant primarily for lambda(not that I ban other formats). I want to ask how should I take that lambda - by value? by reference? or something else.

Example code -

#include <iostream>
#include <functional>
using namespace std;

template<typename Functor>
void f(Functor functor)
{
    functor();
}

void g()
{
    cout << "Calling from Function\n";
}

int main() 
{
    int n = 5;

    f([](){cout << "Calling from Temp Lambda\n";});

    f([&](){cout << "Calling from Capturing Temp Lambda\n"; ++n;});

    auto l = [](){cout << "Calling from stored Lambda\n";};
    f(l);

    std::function<void()> funcSTD = []() { cout << "Calling from std::Function\n"; };
    f(funcSTD);

    f(g);
}

In above code, I've a choice of making it either of these -

template<typename Functor>
    void f(Functor functor)

template<typename Functor>
    void f(Functor &functor)

template<typename Functor>
    void f(Functor &&functor)

What would be the better way and why? Are there any limitations to any of these?

I've always seen functor templated objects passed by value, but I don't know why; good question. — YSC, Feb 21 '17 at 16:48
related/dupe: http://stackoverflow.com/questions/8196345/passing-functor-object-by-value-vs-by-reference-c — NathanOliver, Feb 21 '17 at 16:50

skypjack · Accepted Answer · 2017-02-21T18:12:34.250

16

As a possible drawback, note that passing by copy could not work if the lambda isn't copyable. If you can get away with it, passing by copy is just fine.
As an example:

#include<memory>
#include<utility>

template<typename F>
void g(F &&f) {
    std::forward<F>(f)();
}

template<typename F>
void h(F f) {
    f();
}

int main() {
    auto lambda = [foo=std::make_unique<int>()](){};

    g(lambda);
    //h(lambda);
}

In the snippet above, lambda isn't copyable because of foo. Its copy constructor is deleted as a consequence of the fact that the copy constructor of a std::unique_ptr is deleted.
On the other side, F &&f accepts both lvalue and rvalue references being it a forwarding reference, as well as const references.
In other terms, if you want to reuse the same lambda as an argument more than once, you cannot if your functions get your object by copy and you must move it for it's not copyable (well, actually you can, it's a matter of wrapping it in a lambda that captures the outer one by reference).

edited Feb 21 '17 at 18:12

answered Feb 21 '17 at 17:05

skypjack

49,335
19
95
187

3

@NathanOliver Of course, but you cannot reuse the lambda anymore. If you want to pass it to two functions as in the example, it isn't possible. – skypjack Feb 21 '17 at 17:07
@skypjack followup ques - is it possible to fallback to movable functor in a scenario like this other than defining two similar overloads.. – Abhinav Gauniyal Feb 21 '17 at 17:15
@AbhinavGauniyal By defining two overloads that do exactly the same job, to be able only to not use a forwarding reference? I don't get exactly the benefits. Did I misunderstand something? – skypjack Feb 21 '17 at 17:18
@skypjack I meant having two definitions of `h()` where first one takes by value and 2nd by `&&`.. So that compile doesn't fails. – Abhinav Gauniyal Feb 21 '17 at 17:19
@AbhinavGauniyal And the two functions have exactly the same body or the one that takes the lambda by copy forwards it to the other one. That's a possible approach, of course, if it's worth it for you... – skypjack Feb 21 '17 at 17:40
@skypjack So a non-copyable lambda is one which captures at least one variable of non-copyable type? – KeyC0de Oct 02 '18 at 03:34
1

@Nik-Lz not the best definition ever but close to reality. ;-) – skypjack Oct 03 '18 at 07:01

score 5 · Answer 2 · answered Feb 21 '17 at 17:00

As lambda expressions can have their own fields (like classes), copying / using reference can cause different results. Here's simple example:

template<class func_t>
size_t call_copy(func_t func) {
    return func(1);
}

template<class func_t>
size_t call_ref(func_t& func) {
    return func(1);
}

int main() {
    auto lambda = [a = size_t{0u}] (int val) mutable {
        return (a += val);
    };
    lambda(5);

    // call_ref(lambda); – uncomment to change result from 5 to 6
    call_copy(lambda);

    std::cout << lambda(0) << std::endl;

    return 0;
}

Btw if you want to judge it by performance there's actually no difference, lambdas are very small and easy to copy.

Also – if you want to pass lambda as parameter (not a variable that contains it) you should use forwarding reference so it could work.

"As lambda expressions can have their own fields" and "lambdas are very small and easy to copy" is two contradictory statements. How large a lambda is depends on how large these fields are. One can create an arbitrarily large and very hard to copy lambda. — AnT stands with Russia, Feb 09 '19 at 15:27

passing lambda as argument - by reference or value?

2 Answers2

Linked

Related