Массив функций которые хранятся в одном объекте, но могут быть выполнены по индексу

void func(std::string) {}
 
или 
 
void func(int a, int b, int c) {}

#ifndef func_h
#define func_h
 
#include <windows.h>
#include <functional>
#include <memory>
#include <vector>
 
class ListFunction 
{   
    public: 
        template<class Function, class... Args>
        void AddFunction(Function&& f, Args&&... args)      {
            typedef decltype(std::bind(f, args...)) Call;
            Call* call = new Call(std::bind(f, args...));
            Add<Call>(call);
        }
 
        void RunFunction(int32_t Number)
        {
 
        }
 
    private:
        template <class Call>   
        static unsigned int __stdcall Add(void* arg)        {
            std::unique_ptr<Call> upCall(static_cast<Call*>(arg));
            // decltype(upCall) аналогично std::unique_ptr<Call>
            std::vector<decltype(upCall)> List;
            List.push_back(std::move(upCall));
            (*List[0])();
            return (unsigned long)0;
        }
        
 
};
 
#endif

void Foo(std::wstring str, int64_t a)
{
    std::wcout << L"std:: " << str.data() << " Number: " << a;
}
 
int main()
{
    ListFunction    List;
    List.AddFunction(Foo, L"Text", 2);
 
 
    for (;;){}
 
}

void RunFunction(int32_t Number)
{
(*List[Number])();
}

#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <utility>
#include <functional>
 
class FunctionWrapper
{
    struct baseImpl
    {
        virtual ~baseImpl() = default;
        virtual void call() const = 0;
    };
 
    template <typename B>
    struct bindType : baseImpl
    {
        B func;
 
        template <typename F>
        bindType(F&& f) : func(std::forward<F>(f)) {}
 
        void call() const override { func(); }
    };
 
    std::vector<baseImpl*> funcList;
 
public:
 
    template <typename F, typename ... Args>
    void addFunc(F&& f, Args&& ... args)
    {
        using bind_t = decltype(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
 
        funcList.push_back(new bindType<bind_t>(std::bind(std::forward<F>(f), std::forward<Args>(args)...)));
    }
 
    void runFunc(std::size_t index) const
    {
        funcList[index]->call();
    }
};
 
void foo(std::string s, int n)
{
    for (int i = 0; i < n; ++i)
        std::cout << s << " ";
}
 
int main()
{
    FunctionWrapper fw;
    fw.addFunc(foo, "Hello", 5);
 
    fw.runFunc(0);
}

    FunctionWrapper fw;
    fw.addFunc(foo, "Hello", 5);
    fw.runFunc(0);

..
fw.addFunc(Foo, "Foo");
fw.runFunc("Foo", "Hello", 5);
..

void foo(int);
double bar(std::string);
 
Menu m;
m.add(foo);
m.add(bar);
double d = m.call(1, "test");

typedef void(*FunctionSockBuffer)(int Sock, char *Buffer);
typedef void(*FunctionBuffer)(char *Buffer);
typedef void(*FunctionNull)();
 
typedef void(*FunctionLngClient)(
    OriServerClient &Client,
    OriLng &Lng);
 
typedef void(*FunctionLng)(OriLng &Lng);
typedef void(*FunctionEndConnection)(OriServerClient &Client);
typedef void(*FunctionStartConnection)(OriServerClient &Client);

bool TableFunction::AddFunction(char *Name, FunctionLngClient  Function)
{
 
    if (CountTBLngClient < this->CountMaxFunction)  {
        TBLngClient[CountTBLngClient].Function = Function;
        strcpy(TBLngClient[CountTBLngClient].Name, Name);
        CountTBLngClient++;
        return true;
    }
 
    return false;
}

// Авторизация клиента
void AuthLogin(OriServerClient &Client, OriLng &Lng)  {
    
    char Login[16] = { 0 }, Pass[16] = { 0 };
    Lng.ReturnData(Login, "Login", 16);
    Lng.ReturnData(Pass,  "Pass",  16);
 
    CHECKSTR(Login);
    CHECKSTR(Pass);
...
 
bool GameServer::InitServer() {
 
    // Пересоздадим таблицу функций
    m_Server.SetMaxCountFunction(50);
 
    m_Server << TestNewClient;
    m_Server << TestEndClient;
 
    // Авторизация
    m_Server << "AuthLogin" << AuthLogin;
 
...