How to create a Map in C++ that associates functions to parameters? - c++

Question

Consider that you want to call 100 functions sequentially.
I want to create a map that holds function pointers and function parameters, so that i can iterate the map and call each function with the associated parameters.
The arguments are of different type, arity and return type. Is it possible to implement such map in C++?
Pseudocode
for function in map
// call the function with the arguments from the map
function(map[function])

Answer 1

As stated in the comments, this question is too broad. Therefore, there are too many possible solutions. Also, I really wonder why you need this kind of map of functions. I'm sure if you explained your problem, many would advise you a different kind of solution.
That said, I find the subject interesting, and tried to implement a possible solution to your problem.
As the subject is very broad and the question not specific enough, I had to make some decisions (also based on the comments):
I used a set instead of a map as I had no idea what the (key,value) of the map should be.
I just print out the results (assuming the result is printable), as I have no idea what to do with the result.
Instead of function pointers, I used function objects.
As I was not able to fully understand the pseudo code, the functions are called by an invoke function.
Modifying the below example code should allow you to get what you exactly want. The below code is just an example of what kind of ingredients you might need.
GenericFunction and the set
You can only save one type in a set (or map), so you need some GenericFunction class:
class GenericFunction
{
public:
virtual ~GenericFunction() = default;
virtual void invoke() const = 0; // the method to invoke the function
};
Now, you can define a set which will contain pointers to GenericFunction objects:
std::set<GenericFunction*> myFcts;
Specific function class
Next, let's implement the specific function class which derives from the GenericFunction class. The goal of this class is to store the function and arguments of your choice, and to provide an implementation of the invoke function.
#include <iostream>
#include <tuple>
template <typename Fct, typename ... Args>
class MyFct : public GenericFunction
{
public:
MyFct(Fct fct, Args&& ... args) :
_fct { std::move(fct) },
_args { std::forward<Args>(args)... }
{}
void invoke() const override { std::cout << std::apply(_fct,_args) << std::endl; }
private:
Fct _fct;
std::tuple<Args ...> _args;
};
Testing: sum function
For testing, let's write a simple sum function:
template <typename T>
auto sum(T a)
{
return a;
}
template <typename F, typename ... R>
auto sum(F first, R ... rest)
{
return first + sum(rest...);
}
main function
We can now use the above code like this:
#include <set>
int main()
{
// function wrapper
auto sum_wrapper = [](auto&&... args)
{
return sum(std::forward<decltype(args)>(args)...);
};
// create a specific function
MyFct myf1(sum_wrapper, 1, 2.33/*, add the args of your choice*/);
// create another specific function
MyFct myf2(sum_wrapper, 10, 2.33/*, add the args of your choice*/);
// create the set
std::set<GenericFunction*> myFcts { &myf1, &myf2 };
// call the functions
for (const auto& f : myFcts)
f->invoke();
return 0;
}