Nsryjdtyk

In C++, if I try to do this:

std::function<void(bool,void)>

then the compiler will throw errors. Why is this? It's useful in many cases. One example:

//g++ -std=c++17 prblm.cpp

#include <cstdio>

#include <functional>



template<class type_t>

class some_callback

{

    public:

        using callback_t = std::function<void(bool,type_t)>;

        some_callback(callback_t _myfunc)

        {

            this->myfunc = _myfunc;

        }

        callback_t myfunc;

};



using callback_with_just_bool = some_callback<void>;

using callback_with_an_int_too = some_callback<int>;



int main()

{

    auto my_callback_with_int = callback_with_an_int_too((bool x, int y)

    {

    }); //OK



    auto my_callback_just_bool = callback_with_just_bool((bool x)

    {

    }); //Error



    auto my_callback_just_bool = callback_with_just_bool((bool x,void z)

    {

    }); //Error

    return 0;

}

This allows for a very clean syntax if the user would like to optionally have additional data in their callback, but not have to. However, the compiler will reject code that tries to initialize an object of callback_with_just_bool

Why is it like this, and is there a clean way around it? Thanks.

Edit: The specific reason I'm trying to do this, in real world code, is in an event system. There is data provided to the event system about an individual object that wishes to conditionally receive events (e.x. "if you're close enough to the source, you'll receive a sound event") as well as data provided to a callback about the event (e.x. "a 10khz noise at X200 Y200"). Most of the time, the data needed to check the requirements will exist inside the data provided to the callback about the event, but I wanted to provided an optional additional data structure if that was not the case. Hence, the user would specify "void" if they didn't need this additional data structure.

There is a proposal to add "regular void" to the language.

In it, void becomes a monostate type that all other types implicitly convert to.

You can emulate this with

struct monostate_t {

  template<class T>

  monostate_t(T&&) {}

};

then

using callback_with_just_bool = some_callback<monostate_t>;

auto my_callback_just_bool = callback_with_just_bool((bool x, auto&&...)

{

});

works roughly as you like.

"Why is this?"

Because the only permitted usage of void in a parameter list is to show that the function doesn't accept any parameters.

From [function]:

void

Indicates that the function takes no parameters, it is the exact synonym for an empty parameter list: int f(void); and int f(); declare the same function. Note that the type void (possibly cv-qualified) cannot be used in a parameter list otherwise: int f(void, int); and int f(const void); are errors (although derived types, such as void* can be used)

"Is there a clean way around it?"

I would suggest to specialize for void:

template<class type_t>

class some_callback

{

    std::function<void(bool,type_t)> myfunc;

};



template<>

class some_callback<void>

{

    std::function<void(bool)> myfunc;

};

Variadic templates are one way to do this:

template <class... T>

struct some_callback

{

  std::function<void(bool, T...)> myfunc;

};



using callback_with_just_bool = some_callback<>;

using callback_with_an_int_too = some_callback<int>;

This is even cleaner with an alias template:

template <class... T> using callback_type = std::function<void(bool, T...)>;



int main()

{

  callback_type<int> my_callback_with_int = (bool x, int y)

  {

  }; //OK



  callback_type<> my_callback_just_bool = (bool x)

  {

  }; //OK now too...

}

You might create specialization:

template<class type_t>

class some_callback

{

    std::function<void(bool,type_t)> myfunc;

};



template<>

class some_callback<void>

{

    std::function<void(bool)> myfunc;

};

The problem is not the code you showed, it is because in C/C++, you cannot define a function, f, as

void f(bool b, void v) {}

The reason is that, as @Peter Ruderman said, void is not a valid parameter type.

Other answers have explained the why. This answers "is there a clean way around it?"

What I usually do for callbacks is use lambdas.

std::function<void(void)> myfunc;



bool b = false;

int i = 42;



myfunc = [&]() { if (b) ++i; };