Указатель на функцию с произвольным числом/типо аргументов, описанных строковой декларацией

#include <any>
#include <unordered_map>
#include <string>
#include <functional>
 
class vm
{
    static constexpr size_t num_registers = 8;
 
    // Регистры.
    // Регистр с индексом 0 зарезервирован под
    // возвращаемый результат (не реализованно).
    std::any m_registers[num_registers];
 
    std::unordered_map<
        std::string, // идентификатор
        std::pair<
            std::string,          // описание аргументов
            std::function<void()> // функция
            >>
        m_functions;
 
    void put_args_from_description(std::string const &/*description*/)
    {
        // Какой-то алгоритм заполнения регистров аргументами для вызова функции
        // на основании строкового описания.
        // Например, цикл по символам и последовательное распихивание
        // соответствующих аргументов из типизированных хранилищ.
        //...
    }
 
    // Хэлпер для выбора правильной перегрузки std::any_cast
    template <class T>
    using any_ref = std::conditional_t<std::is_lvalue_reference_v<T>, std::any &, std::any &&>;
 
    // Фактически вызываемая функция, указатель на инстанс которой
    // опосредованно сохраняется.
    template <class R, class... Args, size_t... Idx>
    void invoke_impl(R (*pfn)(Args...), std::index_sequence<Idx...>)
    {
        std::invoke(pfn, std::any_cast<Args>(static_cast<any_ref<Args>>(m_registers[Idx + 1]))...);
    }
 
    // Автоматически заполняет ригистры
    // (для демонстрационного метода vm::call_with_args)
    template <class... Args, size_t... Idx>
    void put_args_impl(std::index_sequence<Idx...>, Args &&...args)
    {
        static_assert(
            sizeof...(Args) < num_registers,
            "the number of arguments exceeds the number of available registers");
 
        (m_registers[Idx + 1].emplace<Args>(std::forward<Args>(args)), ...);
    }
 
public:
    // Регистрирует указатель на функции по имени
    // и строковым описанием аргументов (последнее не ниспользуется).
    template <class R, class... Args>
    void register_function(std::string name, R (*pfn)(Args...), std::string description)
    {
        static_assert(
            sizeof...(Args) < num_registers,
            "the number of arguments exceeds the number of available registers");
 
        m_functions.emplace(
            std::move(name),
            std::make_pair(
                std::move(description),
                [this, pfn]
                {
                    this->invoke_impl(pfn, std::index_sequence_for<Args...>{});
                }));
    }
 
    // Вызов зарегистрированной функции по имени.
    // предполагается, что корректные аргументы были положены в регистры,
    // например, на остновании строкового описания:
    //   put_args_from_description(m_functions.at(name).first));
    void call(std::string const &name)
    {
        m_functions.at(name).second();
    }
 
    // Вызов с аргументами для демонстрации.
    template <class... Args>
    void call_with_args(std::string const &name, Args &&...args)
    {
        put_args_impl(std::index_sequence_for<Args...>{}, std::forward<Args>(args)...);
        call(name);
    }
};
 
#include <iostream>
 
void foo(int i, std::string const &s)
{
    std::cout << "foo: " << i << ' ' << s << '\n';
}
 
void bar(void (*pfn)(int, std::string const &), int &i, std::string const &s)
{
    std::cout << "this call from bar:\n\t";
    pfn(i, s);
}
 
int main()
{
    try
    {
        vm ctx;
        ctx.register_function("foo", foo, "");
        ctx.register_function("bar", bar, "");
 
        // Типы аргументов должны строго соответствовать
        // требуемым функции, т.е. никаких неявных преобразований
        // делаться не будет при извлечении.
        // Чтоб реализовать такую возможность, нужно дополнительно сохранять
        // типы фактических аргументов, чтоб корректно их изъять из регистров,
        // сейчас типы извлекаются на основе "формальных параметров" функции.
        // В случае ошибки вылетит исключение std::bad_any_cast.
        // Возможность передать аргументы по ссылке не реализована,
        // эти аргументы сохраняются в регистрах по значению,
        // но значения в регистрах могут изменяться функцией.
        ctx.call_with_args("foo", 42, std::string("hello foo"));
        ctx.call_with_args("bar", &foo, 33, std::string("hello bar"));
    }
    catch (std::exception const &e)
    {
        std::cerr << e.what() << std::endl;
    }
}