C++ template function, specify argument type of callback functor/lambda while still allow inlining?

Question

What we usually do is like this:

template<class Callback>  
void some_func(Callback const& callback){
   ....
}

What I want is like:

template<class void Callback(int)>  //<---
void some_func(Callback const& callback){// not valid
   ....
}

We can specify the type if we pass by std::function but it disable inlining.

[function_view](https://vittorioromeo.info/index/blog/passing_functions_to_functions.html) might interest you. — Jarod42, May 21 '20 at 13:39

score 3 · Accepted Answer · answered May 21 '20 at 11:10

3

If you have C++20 that's is exactly what the concepts are for

#include <concepts>

template<typename T>
concept Callback = requires(T a) {
    { a(int()) }  -> std::same_as<void>; 
};

template<Callback T> 
void some_func(T const& callback){
  //  ....
}

int a(int) {
    return 0;
}

void b(int) {}

int main() {
    // below does not compile
   // some_func(a);
    some_func(b);
}

answered May 21 '20 at 11:10

bartop

9,971
1
23
54

1

Possibly reuse [invocable concept](https://en.cppreference.com/w/cpp/concepts/invocable). – Jarod42 May 21 '20 at 13:33
@Jarod42 invocable does not check return type – bartop May 21 '20 at 13:49
3

`template concept Callable = std::invocable && std::same_as>;`. – Jarod42 May 21 '20 at 13:58
@Jarod42 care if I copy it to answer? – bartop May 21 '20 at 14:18
You can do it. Sure. – Jarod42 May 21 '20 at 14:23

dewaffled · Answer 2 · 2020-05-21T11:38:05.953

You can use std::enable_if with std::is_invocable (requires C++17 but can be implemented in C++ 14):

#include <type_traits>
#include <iostream>
#include <string>

template <typename F,
          typename = std::enable_if_t<std::is_invocable_v<F, int>>>
void foo(F&& f)
{
    f(1);
}

int main()
{
    // OK
    foo([](int x) { std::cout << x << std::endl; });

    // Still compiles since int is convertible to double
    foo([](double x) { std::cout << x << std::endl; });

    // Compilation error
    // in gcc:
    // error: no matching function for call to 'foo(main()::<lambda(std::string)>)'
    foo([](std::string x) { std::cout << x << std::endl; });
}

C++ template function, specify argument type of callback functor/lambda while still allow inlining?

2 Answers2