How can I store functions with different signatures in a map in C ?

Store Functions with Different Signatures in a Map

In C , you can encounter scenarios where you need to store functions with different signatures in a data structure. Suppose you have a map container that accepts a string key and a generic method as its value. To make this possible, consider the following approach:

Type Erasure and Any Type

C provides the std::any type for type erasure. You can use std::any to store a function pointer or a lambda expression in a container without specifying its exact type. However, to invoke the stored function, you need to cast it to the correct type explicitly.

Operator Overloading for Function Invocation

To overcome the explicit casting, you can define a template operator operator() on a custom wrapper class that takes the stored std::any object as a parameter. This operator allows you to invoke the stored function without the need for explicit casting.

Example Implementation

Here's an example implementation of such a wrapper class:

template<typename ret>
struct AnyCallable
{
    AnyCallable() {}
    template<typename f>
    AnyCallable(F&& fun) : AnyCallable(std::function(std::forward<f>(fun))) {}
    template<typename ... args>
    AnyCallable(std::function<ret> fun) : m_any(fun) {}
    template<typename ... args>
    Ret operator()(Args&& ... args) 
    { 
        return std::invoke(std::any_cast<:function>>(m_any), std::forward<args>(args)...); 
    }
    std::any m_any;
};</args></:function></typename></ret></typename></f></typename></typename>

In this implementation, the AnyCallable class wraps the stored std::any object and provides an operator() that invokes the function with the specified arguments.

Sample Usage

With the AnyCallable class, you can create a map that stores functions with different signatures and invoke them dynamically:

void foo(int x, int y) { /* ... */ }
void bar(std::string x, int y, int z) { /* ... */ }

std::map<:string anycallable>> map;
map["foo"] = &foo;
map["bar"] = &bar;
map["foo"](1, 2);
map["bar"]("Hello", 1, 2);</:string>

Considerations

Note that when invoking the stored functions in a type-erased manner, you need to pass the correct argument types explicitly. Type mismatches will result in a std::bad_any_cast exception.

The above is the detailed content of How can I store functions with different signatures in a map in C ?. For more information, please follow other related articles on the PHP Chinese website!