Anruffunktionen mit mehreren Argumenten

Question

Kann ich in einem Container eine Liste von Elementfunktionen speichern und sie später aufrufen, wenn sie eine andere Anzahl von Argumenten haben.

Ich fühle, dass ich gerade etwas kleines vermisse, aber das ist, wie weit ich habe.

template<typename T> 
class RPCServer 
{ 
public: 
    RPCServer(const std::string host, const int port) {} 
     // Store the method pointers 
    template<typename F> 
    void register_method(const T discriminant, F func) { 
     m_callbacks.emplace_back(discriminant,func); 
    } 

    template<typename... Args> 
    void run(T subject, Args... args) { 
     auto func = std::find(std::begin(m_callbacks), std::end(m_callbacks), subject); 
     if (func != std::end(m_callbacks)) { 
      auto res = std::get<1>(*func)(args...); // This doesn't compile 
     } 

    } 

    ~RPCServer() = default; 
private: 
     // Store 
    std::vector<std::tuple<T, boost::any>> m_callbacks; 
}; 

class Impl 
{ 
public: 
    // RPC methods 
    void send_data(std::string data) {} 
    int get_details(int input) { return 0; } 
}; 

using namespace std::placeholders; 
Impl impl; 
RPCServer<std::string> server("localhost",1234); 
server.register_method("foo", std::bind(&Impl::send_data, impl, _1)); 
server.register_method("bar", std::bind(&Impl::get_details, impl, _1)); 
server.run("foo", "blah"s); // This should call send_data with 'blah' as a arg 
auto result = server.run("bar", 1); // Call get_details passing in 1 

hier einrichten Wie speichere ich/eine Reihe von Mitglieds sicher geben Funktionen abrufen.

Answer 1

Was ist mit dem Erstellen einer Adaptervorlage? Ein Proof-of-Concept-Code:

#include <iostream> 
#include <functional> 

template<typename T0, typename... TS> struct FunCaller { 
    template<class F> FunCaller(F &&f): f(f) {} 
    template<typename... More> T0 operator()(TS &&... as, More &&...) { 
      return f(as...); 
    } 
private: 
    std::function<T0(TS...)> f; 
}; 
template<typename T0, typename... TS> inline FunCaller<T0, TS...> funCaller(T0(&&f)(TS...)) { return FunCaller<T0, TS...>(f); } 

std::ostream &printSome(std::string const &s1, std::string const &s2) { return std::cout << s1 << ", " << s2 << std::endl; } 

int main() { 
    auto omg = funCaller(printSome); 
    omg("Hello", "world!", "This", "is", "cocaine", "speaking"); 
}