How to properly declare a method that only takes a lambda?

Question

In the following example, I would like a traverse method that receives a callback. This example works perfectly as soon as I don't capture anything [] because the lambda can be reduced into a function pointer. However, in this particular case, I would like to access sum.

struct Collection {
    int array[10];

    void traverse(void (*cb)(int &n)) {
        for(int &i : array)
            cb(i);
    }

    int sum() {
        int sum = 0;
        traverse([&](int &i) {
            sum += i;
        });
    }
}

What is the proper way (without using any templates) to solve this? A solution is to use a typename template as follows. But in this case, you lack visibility on what traverse gives in each iteration (an int):

template <typename F>
void traverse(F cb) {
    for(int &i : array)
        cb(i);
}

Answer 1

Lambda types are unspecified; there is no way to name them.

So you have two options:

• Make traverse a template (or have it take auto, which is effectively the same thing)

  Fortunately this is a completely normal and commonplace thing to do.

• Have traverse take a std::function<void(int)>. This incurs some overhead, but does at least mean the function need not be a template.

But in this case, you lack visibility on what traverse gives in each iteration (an int)

We don't tend to consider that a problem. I do understand that giving this in the function's type is more satisfying and clear, but generally a comment is sufficient, because if the callback doesn't provide an int, you'll get a compilation error anyway.

Answer 2

Only captureless lambdas can be used with function pointers. As every lambda definition has its own type you have to use a template parameter in all places where you accept lambdas which captures.

But in this case, you lack visibility on what traverse gives in each iteration (an int).

This can be checked easily by using SFINAE or even simpler by using concepts in C++20. And to make it another step simpler, you even do not need to define a concept and use it later, you can directly use an ad-hoc requirement as this ( this results in the double use of the requires keyword:

struct Collection {
    int array[10];


    template <typename F>
        // check if F is "something" which can be called with an `int&` and returns void.
        requires requires ( F f, int& i) { {f(i)} -> std::same_as<void>; }
        void traverse(F cb) 
        {   
            for(int &i : array)
                cb(i);
        }

     // alternatively you can use `std::invocable` from <concepts>

    // check if F is "something" which can be called with an `int&`, no return type check 
    template <std::invocable<int&> F>
        void traverse2(F cb) 
        {   
            for(int &i : array)
                cb(i);
        }   

    int sum() {
        int sum = 0;
        traverse([&](int &i) {
            sum += i;
        });

        return sum;
    }
};

Answer 3

In your case you have several ways of declaring a callback in C++:

Function pointer

void traverse(void (*cb)(int &n)) {
    for(int &i : array)
        cb(i);
}

This solution only supports types that can decay into a function pointer. As you mentioned, lambdas with captures would not make it.

Typename template

template <typename F>
void traverse(F cb) {
    for(int &i : array)
        cb(i);
}

It does accept anything, but as you noticed. the code is hard to read.

Standard Functions (C++11)

void traverse(std::function<const void(int &num)>cb) {
    for(int &i : array)
        cb(i);
}

This is the most versatile solution with a slightly overhead cost.

Don't forget to include <functional>.