How to define a vector of functions that accepts different parameter types in c++?

Question

I am doing a challenge for myself and writing a program in C++ without using classes and class related machinery. Additional conditions are I can use everything from stl and have full type safety, meaning no raw pointers or casting from one type to another. I am now in a situation where I'm not sure how to proceed with the constraints I have put on myself.

Problem: I want to create a std::vector of functions, but each of those functions might take a different data type, and operate on that type only. Example:

struct DataAndFunction {
    AnyDataType data;
    std::function<void(AnyDataType&)> functionOperatingWithData;
};
...
std::vector<DataAndFunction> listOfFunctions;
...
for(auto& dataAndFunc : listOfFunctions) {
    dataAndFunc.functionOperatingWithData(dataAndFunc.data);
}

then there either would be different kind of AnyDataType and accompanying functions.

I know it could be solved in a couple of ways:

1. with classes using polymorphism, where

   std::vector< DataAndFunction > listOfFunctions;

would just take a base class as a template parameter, and would have virtual method, that would be implemented by child classes, each with their own private data members, but the point of my challenge is to not use this pattern.

2. I could pass void* as data and function signature, and inside each function I would cast the data to the appropriate type, but I want to use type safety and only smart pointers

I could also make DataAndFunction struct a generic by adding template parameter, but then how do I make a vector that could be filled with not just with of DataAndFunction<int> for example, but any template parameter?

And how would this problem be solved in a more functional style? How would a functional solution look in C++ that would operate on a list of functions each taking a different type of argument? Without using inheritance of course.

Or am I just asking how to emulate a virtual table?

Answer 1

It seems you only need std::function<void()>:

DataAndFunction<int> dint;
DataAndFunction<char> dchar;
std::vector<std::function<void()>> funcs{
    [&](){ dint.f(dint.data); },
    [&](){ dchar.f(dchar.data); },
    [](){ std::cout << "Hello world\n"; }
};

for (auto& f : funcs) {
    f();
}

Answer 2

How you know, C++ is a strong typed language. That means you can't have a generic variable like others languages do like Python.

In C, the solution is to use a point to void (void*), but it is hard to manage and error-prone.

C++17 comes with 2 elegant solutions these you can use:

std::any and std::variant.

Answer 3

This is one way you could store a vector of functions that take different types as parameters, it also accepts a varying amount of parameters. It uses std::any, std::pair, and std::tuple to contain the function and its parameter(s). std::any is much safer than a void * however there is more memory overhead as std::any stores quite a bit of data.

the program simply outputs : "Hello World!"

#include <any>
#include <tuple>
#include <string>
#include <vector>
#include <utility>
#include <iostream>
#include <functional>

std::vector<std::pair<std::function<void(const std::any&)>, std::any>> funcList;

template <typename F, typename...T>
std::size_t insertAnyFunc(const F &func, const T&...params) {
    auto t = std::make_tuple<const T&...>(params...);
    funcList.push_back({
        [f = func](const std::any &a) {
            if constexpr (sizeof...(T) == 0)
                f();
            else
                std::apply(f, std::any_cast<const std::tuple<T...> &>(a));
        }, std::make_any<std::tuple<T...>>(t)
    });
    return funcList.size();
}

void execAnyFunc(const std::size_t &ID) {
    if (ID < funcList.size())
        funcList.at(ID).first(funcList.at(ID).second);
}

int main (void) {
    insertAnyFunc([](const std::string &s){ std::cout << s; }, std::string("Hello World!\n"));
    execAnyFunc(0);
    return 0;
}