0

How do each of the following behave differently?

I'm unclear what effect const has on the function parameter, and what the difference in this case would be between passing by value, by reference, or by rvalue reference.

Note that I understand the distinction between pass by value and pass by reference. In the specific case of std::function, or more particularly lambdas, though, I'm not sure what passing the lambda by value vs. passing the lambda by reference does. What would it mean to pass the lambda by value? What is the data that would be copied?

Also is there any practical distinction between const and not with regard to lambdas?

#include <functional>

void foo_with_func(      std::function<void()>   f) { ...; f(); ...; }
void foo_with_func(      std::function<void()>&  f) { ...; f(); ...; }
void foo_with_func(      std::function<void()>&& f) { ...; f(); ...; }
void foo_with_func(const std::function<void()>   f) { ...; f(); ...; }
void foo_with_func(const std::function<void()>&  f) { ...; f(); ...; }
void foo_with_func(const std::function<void()>&& f) { ...; f(); ...; }

All with the same usage:

foo_with_func([&]() { ... });
Claudiu
  • 224,032
  • 165
  • 485
  • 680
  • 1
    You could search stack overflow first, as there are many related questions. – Thomas Matthews Apr 02 '15 at 17:45
  • 1
    Possible duplicate: [When should I pass by reference?](http://stackoverflow.com/questions/4986341/where-should-i-prefer-pass-by-reference-or-pass-by-value) – Thomas Matthews Apr 02 '15 at 17:46
  • 1
    Possible duplicate: [Pass by value or const reference...](http://stackoverflow.com/questions/28204556/pass-by-value-or-const-reference-to-function) – Thomas Matthews Apr 02 '15 at 17:47
  • There are many related topics available on Stack Overflow or just google them –  Apr 02 '15 at 17:48
  • I understand the distinction in general between pass by value and pass by reference. In the specific case of `std::function`, or more particularly lambdas, though, I'm not sure what passing the lambda by value vs. passing the lambda by reference does. What would it mean to pass the lambda by value? Most of the questions related to "lambda pass by value" or "lambda pass by reference" refer to the lambda capture. – Claudiu Apr 02 '15 at 17:49

2 Answers2

4

Given the proposed usage foo_with_func([&]() { ... });,

void foo_with_func(      std::function<void()>&  f) { ...; f(); ...; }

will not compile because it binds a non-const lvalue reference to a temporary. The rest are equivalent in any decent optimizing compiler. If you want to also call it with a std::function<void()> func;, then by passing const lvalue reference may be more efficient than passing by value.

None of them, however, is the most efficient, because all incur type erasure costs. To avoid those costs, write a template and accept the lambda directly.

template<class F>
void foo_with_func(F f){ f(); }

You can also use F&& if the lambda captures by value and copying can be expensive.

T.C.
  • 133,968
  • 17
  • 288
  • 421
  • Ah that last sentence helps me understand. So if the lambda captures by value, then passing it by value will copy all of the things it captures, of course. Question about the last example, I could also do `foo_with_func(const F& f){ f(); }` to avoid copying right? – Claudiu Apr 02 '15 at 20:34
  • 1
    @Claudiu Right, but of course that won't work with a `mutable` lambda. – T.C. Apr 02 '15 at 21:06
0

Rules of Thumb:

Constant Parameters

Plain old data types, such as double, int, and char should be passed by value (copy). They fit into a processors register, and also any other mechanism may require more processing or memory.

Larger data structures should be passed by constant reference. Copying larger structures onto the stack occupies a lot of memory and requires extra processing. Passing a reference means that you are referring to an existing item. Passing a constant reference means that the function will not change the item referenced.

Mutable Parameters

A parameter that will be modified by the function should be passed by reference. This allows your program to modify the item "in place".

Note: I haven't played with move semantics so I can't recommend whether or not to use move semantics.

Thomas Matthews
  • 56,849
  • 17
  • 98
  • 154
  • 1
    Not since c++11. Passing by value is recommended in most cases unless you specifically want to re-use the object after the call - r-value references and copy elision have removed (most) of the drivers for passing by const ref. – Richard Hodges Apr 02 '15 at 22:08