Member function template deduction guide or other method to let the compiler know how to call function

Question

struct setup_entry 
{
    template< typename T >
    void Disable( bool(*p)(T*) ) { ... }
}

Calling Disable:

setup_entry X;

Case 1: X.Disable( [](int*)->bool{...} );        //FAIL to deduce T
Case 2: X.Disable<int>( [](int*)->bool{...} );   //OK   to deduce T

I would like to use case 1. (Easier for the user)

Any ideas?

The simplified final solution for the record was to do this:

template< typename T >
void Disable( T&& Callback )
{ 
   auto p = +Callback;
   ...
}

Unrelated to your problem, but I would recommend against using function pointers as arguments. Either use templates (as all of the standard library does) or use `std::function`. That way you can use *any* callable object (like for example lambdas *with* captures). By the way, unless you need `T` inside your function, using a template for the function object itself would also solve your problem. — Some programmer dude, Feb 07 '19 at 11:39

songyuanyao · Accepted Answer · 2019-02-07T13:26:09.310

4

You can't do that because implicit conversion (from lambda to function pointer) won't be considered in template argument deduction; T can't be deduced.

Type deduction does not consider implicit conversions (other than type adjustments listed above): that's the job for overload resolution, which happens later.

If you want to stick to auto type deduction, you can convert the lambda to function pointer explicitly, e.g.

X.Disable(+[](int*)->bool{...} ); 
//        ^

Or

X.Disable(static_cast<bool(*)(int*)>([](int*)->bool{...}));

edited Feb 07 '19 at 13:26

answered Feb 07 '19 at 11:43

songyuanyao

169,198
16
310
405

1

Ha, the first version is as awesome as concise! Do you mind elaborating a bit on the unary `+`? – lubgr Feb 07 '19 at 11:46
1

@songyuanyao Interesting use of unary `+`! – L. F. Feb 07 '19 at 11:47
1

@lubgr & L. F. See [this](https://stackoverflow.com/questions/18889028/a-positive-lambda-what-sorcery-is-this). – songyuanyao Feb 07 '19 at 11:49

score 1 · Answer 2 · answered Feb 07 '19 at 11:44

First you should know that the type of [](int*) -> bool {...} is not just bool(int*) or bool(*)(int*); it is a unique closure type convertible to bool(*)(int*).

And this type is not deducible in this context.

A solution: explicitly do the conversion.

X.Disable( static_cast<bool(*)(int*)>([](int*) -> bool {...}) );

Better solution: as @Some programmer dude says, use a template or use std::function. For example:

template <typename F>
void Disable(F f)
{
    static_assert(std::is_invocable_r_v<bool, F, int*>, "your message here"); // if you want to ensure that the function is actually valid
    // ...
}

Or:

void Disable(std::function<bool(int*)> f) { ... }

Member function template deduction guide or other method to let the compiler know how to call function

2 Answers2