Можно ли создать указатель на функции разного типа?

void* (*Function) ();

Function ();

    auto &&ref=Fun;
    ref();

if (exe_num)
{
  switch (exe_num)
  {
  case 1: Fun1 (); break;
  case 2: Fun2 (arg); break;
  case 3: ret_var1 = Fun3 (); break;
  case 4: ret_var2 = Fun4 (&arg_ref); break;
  // и т. д.
  default: break;
  }
  exe_num = 0;  // Сброс запроса
}

class executor
{
public:
    void execute() = 0;
};
 
class fun1 : public executor
{
public:
    fun1();
    
    void execute() override     { Fun1(); }
};
 
class fun2 : public executor
{
public:
    fun2(int arg)
    : Arg(arg)
    {}
    
    void execute() override     { Fun2(Arg); }
private:
    int const Arg;
};
 
 
void test()
{
    if(!busy())
        Fun1();
    else
        Queue.push(new fun1);
    int Arg = 123;
    if(!busy())
        Fun2(Arg);
    else
        Queue.push(new fun2(Arg));
}
 
void process_queue()
{
    for(;;)
    {
        executor * To_do = Queue.pop();
        if(!To_do)
            break;
        To_do.execute();
    }
}

#include <iostream>
#include <functional>
#include <vector>
#include <memory>
 
void foo(){std::cout << "foo" << std::endl;}
bool bar(const char*){return static_cast<bool>(std::cout << "bar" << std::endl);}
 
struct BaseCaller{
   virtual void Call() = 0;
   virtual ~BaseCaller() = default;
};
 
template< class Func, class Result, class... Args>
struct BindedFunctionWithResult : BaseCaller{
   BindedFunctionWithResult(Func&& f, Result& res, Args&&... args)
      :func{std::bind(std::forward<Func>(f), std::forward<Args>(args)...)},
       res{res}{
   }
   virtual void Call(){
      res = func();
   }
protected:
   std::function<Result()> func;
   Result& res;
};
 
template<class Func, class... Args>
struct BindedFunctionWithResult<Func, void, Args...> : BaseCaller{
   BindedFunctionWithResult(Func&& f, Args&&... args)
      :func{std::bind(std::forward<Func>(f), std::forward<Args>(args)...)}{
   }
   virtual void Call(){
      func();
   }
protected:
   std::function<void()> func;
};
 
template<class Func, class... Args>
struct BindedFunction : BindedFunctionWithResult<Func, std::invoke_result_t<Func, Args...>, Args...> {
   using BindedFunctionWithResult<Func, std::invoke_result_t<Func, Args...>, Args...>::BindedFunctionWithResult;
};
 
int main(){
   /*
   BindedFunction<decltype(foo)> b1(foo);
   ((BaseCaller*)(&b1))->Call();
 
   bool res = false;
   BindedFunction<decltype(bar), const char*> b2(bar, res, "Hello World");
   ((BaseCaller*)(&b2))->Call();
   std::cout << res << std::endl;
   */
 
   bool res = false;
   std::vector<std::unique_ptr<BaseCaller>> vf;
   vf.push_back(std::unique_ptr<BaseCaller>(new BindedFunction<decltype(foo)>(foo)));
   vf.push_back(std::unique_ptr<BaseCaller>(new BindedFunction<decltype(bar), const char*>(bar, res, "Hello World")));
 
   vf[0]->Call();
   vf[1]->Call();
   std::cout << res << std::endl;
}