1

Is there a way to store void functions with different parameters in a vector? The number of parameters is always one, only the type differs. The parameter type can be a default type like int, a pointer to my own object like example* or any other type.

What I do for now is using a vector of functions with a void pointer as parameter. So I can pass everything. But I want to get rid of the back casting in all the functions.

unordered_map<string, function<void(void*)> > List;

void Callback(string Name, function<void(void*)> Function)
{
    List[Name].push_back(&Function);
}

Callback("event", [](void* x){
    int value = *(int*)x;
    cout << value << endl;
});

Here is an example to illustrate what I would like to have. Please note the template syntax I would prefer. Therefore I would need to store all the functions in a container.

vector<function<void(...)> > List; // need something other than a std vector

template <typename T>
void Callback(string Name, function<void(T)> Function)
{
    List[Name].push_back(&Function);
}

Callback<int>([](int x){
    cout << x << endl;
});

This application is performance related since it is an essential part of a realtime rendering engine.

Edit: I solved the point of storing functions without parameters, so this is not part of the question anymore what makes the question more clear and straightforward.

Improve this question
8
  • At the call site, how do you know which argument type to use? Commented Dec 1, 2012 at 11:32
  • For now, it is a void pointer, too. But I would like to templatize that, too. Commented Dec 1, 2012 at 11:34
  • 1
    The interesting bit of information is how do you know which type to use, not how do you currently represent it. Assume that you have vector<Foo> v where Foo is just the right type. You want to call v[3](x). What type do you want x to be? Commented Dec 1, 2012 at 11:48
  • There is a constraint for all callback functions to have either no or the same parameter as the event provides. For example the event WindowResize provides a Vector2i for the new height and width. All registered callbacks must have none or just a Vector2i parameter. But as I said my actual implementation uses void pointers so only the programmer knows the type. Commented Dec 1, 2012 at 12:04
  • So the programmer knows that WindowResize has data of type Vector2i etc, and he wants to express this knowledge using only statically type safe constructs of the language. Why he lumps all callbacks of all possible types in the same vector then? By doing this, he throws away the knowledge. Why not separate callbacks that accept an int from those that accept Vector2i etc in a different variables, of different types? Then each event type will know where to find relevant callbacks. Commented Dec 1, 2012 at 14:27

3 Answers 3

Reset to default
1

If type of parameters that could passed to the function is limited, then one option is using something like boost::variant:

typedef boost::variant<
    std::function<void()>,
    std::function<void(int)>,
    std::function<void(long)>,
    std::function<void(std::string const&)>
> my_functions;
typedef std::vector<my_functions> functions_list;

Then you can insert your callbacks directly into container.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

Sorry, I need to pass hole classes, not only default types. I updated my question for this fact.
Sorry I don't get your comment, could you please explain it!
Your introducing sentence does not apply. The types of parameters are not limited to int, float, string, ... I need to pass objects of my own classes.
I said you can use it if list of types are limited, but not limited to this set, this is just a sample, you may replace this types with any other types and your variant may have 50 different types. Please just read documentation of boost::variant.
So you may use boost::any instead of void*, using it you can have safe cast and ensure that you are calling function with correct parameters
|
1

As n.m pointed out in a comment, the issue is how you use the value. Formally, C++ allows you to convert any pointer to (non-member) function to a void (*)(void) and back to its original type, without loss of value—void (*)(void) can be considered a sort of void* for pointers to functions. And practically, the runtime cost of such conversions is zero. But in order to use the function, at some point, you have to know the original type, in order to convert the pointer back to it.

You don't give your use case, but the usual situation involves callbacks, where the registration of the callback has a void (*)( void* ) (or void (*)( void const* )), and the callback converts the void* to the correct type, and calls a member function on it. In this case, using void* as the generic argument is the correct (and probably the only) solution.

Of course, this is the C solution, and should usually only be used when the interface using the callback is defined using the C API (functions like pthread_create, for example). In C++, the solution is to register objects, which derive from the same abstract base class, and implement a specific pure virtual function.

Improve this answer

3 Comments

Internally the event system can use void pointers. But I would like a way to get rid of converting back the parameter. Therefore I would like templates.
Well, it's fairly easy to wrap the functions in templates. The problem is that usually, if you're using this idiom, it's because the interface is designed using a C API (otherwise, there are better solutions). To pass a pointer to a function to a C API, the function must be extern "C", and a template cannot be extern "C".
Could you provide an example? By the way, I don't depend on any C API.
1

I developed a void pointer based event system and it works now. It uses templates for passing and receiving data. Functions with none or one parameter of any type both are supported. Since it uses void pointers to store the callback functions I suppose it is very fast compared to a solution using the any type from boost framework.

#include <string>
#include <vector>
#include <unordered_map>
#include <functional> 
#include <memory>

using namespace std;

class ManagerEvent
{
    typedef unordered_map<string, unordered_map<int, vector<pair<void*, bool> > > > Events;
public:
    void Listen(string Name, function<void()> Function)
    {
        Listen(Name, 0, Function);
    }
    void Listen(string Name, int State, function<void()> Function)
    {
        List[Name][State].push_back(make_pair(new function<void()>(Function), false));
    }
    template <typename T>
    void Listen(string Name, function<void(T)> Function)
    {
        Listen<T>(Name, 0, Function);
    }
    template <typename T>
    void Listen(string Name, int State, function<void(T)> Function)
    {
        List[Name][State].push_back(make_pair(new function<void(T)>(Function), true));
    }
    void Fire(string Name)
    {
        Fire(Name, 0);
    }
    void Fire(string Name, int State)
    {
        auto Functions = List[Name][State];

        for (auto i = Functions.begin(); i != Functions.end(); ++i)
        {
            if(i->second) continue;
            else          (*(function<void()>*)(i->first))();
        }
    }
    void FireRange(string Name, int From, int To)
    {
        for(int i = From; i <= To; ++i) Fire(Name, i);
    }
    template <typename T>
    void Fire(string Name, T Data)
    {
        Fire(Name, 0, Data);
    }
    template <typename T>
    void Fire(string Name, int State, T Data)
    {
        auto Functions = List[Name][State];

        for (auto i = Functions.begin(); i != Functions.end(); ++i)
        {
            if(i->second) (*(function<void(T)>*)i->first)(Data);
            else          (*(function<void()>*)i->first)();
        }
    }
private:
    Events List;
};

This is what came to my mind and it works quite well. However, please feel free to suggest improvements or use the code for your own projects.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.