Default argument for a functor in a templated parameter

Question

I would like to have a default lambda for a functor argument in my function.

I am aware it is possible using a struct and operator() like this:

struct AddOne {
    int operator()(int a) {
        return a+1;
    }
};

template <typename Functor = AddOne>
int run_old(int x, Functor func = AddOne()) 
{
    return func(x);
}

But I was wondering if there was a modern way, given the changes in the standard in either c++14/17/20, to make this work?

template <typename Functor>
int run_new(int x, Functor func = [](int a){ return a+1; }) 
{
    return func(x);
}

I'm not sure what one would use as the default type to Functor, or if there is syntax i'm unaware of.

https://godbolt.org/z/Hs6vQs

"*modern way*" What's wrong with the old way? The struct method is much easier to read at the function site. — Nicol Bolas, Sep 04 '19 at 15:11
In the _old way_, you likely don't want to provide both default template and function arguments this way: https://wandbox.org/permlink/PtSwiQwsNDyDrshu. Use `Functor func = Functor()` instead. — Daniel Langr, Sep 04 '19 at 15:15

score 8 · Accepted Answer · answered Sep 04 '19 at 15:12

8

From C++11 you can already do that:

template <typename Functor = int(int)>
int run_new(int x, Functor func = [](int a){ return a+1; }) 
{
    return func(x);
}

answered Sep 04 '19 at 15:12

BiagioF

9,368
2
26
50

works only with non-capturing lambda, no? (not relevant for the question as asked) – 463035818_is_not_an_ai Sep 04 '19 at 15:14
1

@formerlyknownas_463035818: If you pass a capturing lambda, then the template function will deduce the type of this lambda, thus overriding the default type of `int(int)`. – Nicol Bolas Sep 04 '19 at 15:15
3

@formerlyknownas_463035818 I don't think you can capture anything in this context since the lambda is used as a default argument. – BiagioF Sep 04 '19 at 15:15
@BiagioFesta oh right ;) maybe some globals but I dont care about them – 463035818_is_not_an_ai Sep 04 '19 at 15:16
1

@formerlyknownas_463035818 You couldn't capture a global anyway. Capturing requires *automatic* storage. – BiagioF Sep 04 '19 at 15:18
2

Note that GCC and Clang are smart enough to inline the lambda call even though it gets converted into a function pointer. https://godbolt.org/z/nl4qEj – Brian Bi Sep 04 '19 at 15:20

NathanOliver · Answer 2 · 2019-09-04T15:13:07.280

3

Just add an overload for this.

template <typename Functor>
int run_new(int x, Functor func) 
{
    return func(x);
}

int run_new(int x) 
{
    return run_new(x, [](int a){ return a+1; });
}

Allows you to get around not beening able to have a lambda expression as a default function argument.

edited Sep 04 '19 at 15:13

answered Sep 04 '19 at 15:12

NathanOliver

171,901
28
288
402

score 1 · Answer 3 · answered Sep 04 '19 at 15:12

1

Not quite "modern" but you could use plain old overloading with a non-template method taking only a single parameter:

int run_new(int x) 
{
    return func(x,[](int a){ return a+1;});  // calls the template overload
}

answered Sep 04 '19 at 15:12

463035818_is_not_an_ai

109,796
11
89
185

score 1 · Answer 4 · answered Sep 04 '19 at 15:53

Just for fun, in C++20 we have both (1) lambdas in unevaluated contexts and (2) lambdas without capture are default constructible. Combine those two and you get:

template <typename Functor = decltype([](int a){ return a+1; })>
int run_new(int x, Functor func = {})
{
    return func(x);
}

Obligatory godbolt.

score 0 · Answer 5 · edited Sep 04 '19 at 15:26

0

Alternatively to other questions, you can even avoid templates:

int run_new(int x, std::function<int(int)> func = [](int a){ return a + 1; })
{
   return func(x);
}

edited Sep 04 '19 at 15:26

BiagioF

9,368
2
26
50

answered Sep 04 '19 at 15:21

Daniel Langr

22,196
3
50
93

5

Do note that you do incur a cost for this. `std::function` uses type erasure so you have dynamic allocation and more than likely lose the ability to inline the code. – NathanOliver Sep 04 '19 at 15:24
2

@NathanOliver Both GCC and Clang seem to be smart enough to generate the same inlined assembly code for `f`, which is minimal: https://godbolt.org/z/uuEeNE. Need to admit I was surprised. – Daniel Langr Sep 04 '19 at 15:26
3

@DanielLangr But now the functor has to be copyable – Artyer Sep 04 '19 at 15:30
@Artyer That's the drawback. The advantage is that you don't need to expose the function definition in a header file. – Daniel Langr Sep 04 '19 at 15:32

score 0 · Answer 6 · answered Sep 04 '19 at 15:27

0

The best I can imagine pass through a variable

static constexpr auto defFunc = [](int a){ return a+1; };

template <typename Functor = decltype(defFunc)>
int run_new(int x, Functor func = defFunc) 
{
    return func(x);
}

answered Sep 04 '19 at 15:27

max66

65,235
10
71
111

Default argument for a functor in a templated parameter

6 Answers6