Переработка переменных аргументов из массива void** в C++

Я работаю над проектом, в котором мне нужно преобразовать переменные аргументы в массив void**, передать их в лямбда-функцию, а затем правильно привести их обратно к исходным типам для использования в пользовательской функции. Хотя я могу успешно создать массив void**, у меня возникают проблемы с правильным расширением и приведением переменных аргументов обратно к их исходным типам внутри лямбда-функции. Пользовательская функция предназначена для обработки этих аргументов, но выдаются неправильные значения, что указывает на проблему с тем, как я обрабатываю массив void** и последующие приведения.

Важно отметить, что это предназначено для использования с любой функцией, не ограничиваясь только показанными типами, что отличается от других примеров, которые я нашел при переполнении стека.

Ниже приведен минимальный воспроизводимый пример моего подхода. Он демонстрирует:

• Захват переменных аргументов и их адресов.
• Сохранение указателя функции и адресов аргументов как void*.
• Использование лямбды для переосмысления и приведения этих указателей к их исходным типам.
• Применение пользовательской функции к этим аргументам.

Я разделил расширение параметров в целях отладки с помощью функции helper(...).

Может ли кто-нибудь помочь мне определить, почему аргументы не возвращаются к исходным типам правильно и как правильно обработать это преобразование?

#include <iostream>
#include <tuple>

// Implementation of the forwarder function
void raw_forwarder(void (*f)(void **), void **args) {
    f(args);
    // some other procedure in here
}

// Base case helper function
template<typename T>
static auto helper(T &arg) {
    std::cout << "helper 2 - val:\t" << arg << "\tat: " << &arg << std::endl;
    return std::make_tuple(arg);
}

// Recursive helper function
template<typename T, typename... Args>
static auto helper(T &arg, Args &... args) {
    std::cout << "helper 1 - val:\t" << arg << "\tat: " << &arg << std::endl;
    return std::tuple_cat(std::make_tuple(arg), helper(args...));
}

template<typename F, typename... Args>
static void forwarder(F &f, Args &... args) {

    // Create an array of void* to hold the addresses of the arguments
    void *argArray[] = {reinterpret_cast<void *>(&f), reinterpret_cast<void *>(&args)...};

    // Call the raw forwarder with the function and arguments
    raw_forwarder([](void **args_raw) {
                      // Retrieve the function pointer
                      F &reinterpreted_func = *reinterpret_cast<F *>(args_raw[0]);

                      // Create a tuple of argument pointers using the helper functions
                      auto arg_tuple = helper(*reinterpret_cast<Args *>(args_raw[1])...);

                      std::cout << std::endl;

                      // Apply the function to the dereferenced arguments
                      std::apply([&reinterpreted_func](auto &&... unpacked_args) { reinterpreted_func(unpacked_args...); }, arg_tuple);
                  },
                  argArray);
}

void custom_function(int val1, float val2, double val3) {
    std::cout << "val1 = " << val1 << std::endl;
    std::cout << "val2 = " << val2 << std::endl;
    std::cout << "val3 = " << val3 << std::endl;
}

int main() {
    int val1 = 7;
    float val2 = 5.5f;
    double val3 = 10.0;

    helper(val1, val2, val3); // this works
    std::cout << std::endl;

    forwarder(custom_function, val1, val2, val3);

    return 0;
}

Вырезанный из вышеизложенного вывод (показан ниже). Я заметил, что при расширении указателей проблема заключается в том, что для всех параметров передается одно и то же значение указателя. Это приводит к использованию неверных значений в пользовательской функции. Как я могу правильно расширить и привести аргументы с вариациями, чтобы избежать этой проблемы?

helper 1 - val: 7       at: 0x4fcd9ff84c
helper 1 - val: 5.5     at: 0x4fcd9ff848
helper 2 - val: 10      at: 0x4fcd9ff840

helper 1 - val: 7       at: 0x4fcd9ff84c
helper 1 - val: 9.80909e-45     at: 0x4fcd9ff84c
helper 2 - val: 3.45846e-323    at: 0x4fcd9ff84c

val1 = 7
val2 = 9.80909e-45
val3 = 3.45846e-323

Для справки: в режиме отладки, если посмотреть на args_raw, как показано ниже, я вижу, что ячейки действительно указывают на фактические значения.

  *reinterpret_cast<int*>(args_raw[1])
  *reinterpret_cast<float*>(args_raw[2])
  *reinterpret_cast<double*>(args_raw[3])