Variadic - come posso creare il tipo, che memorizza gli argomenti passati

Question

Supponiamo quindi di avere una classe, che contenga oggetti funzionali e nella chiamata del costruttore passino gli argomenti, che devono essere passati all'oggetto funzionale un po 'di tempo dopo. Qualcosa di simile:

class Binder{ 
public: 
    Binder(functional_object, listOfParameters); 
    callFunctionalObject(); // calls functional object with given list of parameters 
}; 

Prima di C++ 11 non ho potuto utilizzare i modelli variadic, così si potrebbe fare:

struct none{}; 

template <typename T1, typename T2=none, typename T3=none> 
class Binder{ 
public: 
    Binder(T1 functionalObject, T2 arg1=none(), T3arg3=none()); 
    void callFunctionalObject(); 
private: 
    T1 m_functionalObject; 
    T2 m_arg1; 
    T3 m_arg2; 
}; 

Dove callFunctionalobject potrebbero essere attuate come segue:

template<typename T1, typename T2, typename T3> 
void Binder<T1,T2,T3>::callFunctionalObject(){ 
    callImpl(m_functionalObject, m_arg1, m_arg2); 
} 

e callImpl verrebbe sovraccaricato per riconoscere oggetti di tipo none per passare una quantità adeguata di argomenti all'oggetto funzionale.

Ora passando a C++ 11 non so come implementare il fatto, che nella sezione privata ho membri, a cui ho un accesso diretto.

Qualcuno potrebbe spiegarmi il modo in cui posso fare lo stesso utilizzando C++ 11 o C++ 14?

Answer 1

È necessario memorizzare un std::function e un std::tuple e quindi chiamare la funzione sulla tupla.

Qui una soluzione di lavoro C++ 14

#include <iostream> 
#include <functional> 

template<typename T1, typename ...T> 
class Binder 
{ 
public: 
    Binder(std::function<T1(T...)> f, std::tuple<T...> t) : m_functional_obj(f), m_parameters(t) {} 

    template<std::size_t ...I> 
    T1 callImpl(std::index_sequence<I...>) 
    { 
     return m_functional_obj(std::get<I>(m_parameters)...); 
    } 

    T1 callFunctionalObject() 
    { 
     return callImpl(std::index_sequence_for<T...>{}); 
    } 
private: 
    std::function<T1(T...)> m_functional_obj; 
    std::tuple<T...>  m_parameters; 
}; 

int test(int i) 
{ 
    std::cout << "test(" << i << ")" << std::endl;  
    return i + 1; 
} 

int main() 
{ 
    Binder<int,int> bibi(test, std::make_tuple<int>(2)); 
    auto res = bibi.callFunctionalObject(); 
    std::cout << "res is " << res << std::endl; 
} 

Live code

Answer 2

Il modo più semplice è quello di memorizzare un oggetto std::function con argomenti già impostati utilizzando std::bind:

class Binder{ 
public: 
    template <typename T1, typename... T2> 
    Binder(T1 functionalObject, T2... args) : f(std::bind(functionalObject, args...)) {} 
    void callFunctionalObject() { f(); } 
private: 
    std::function<void()> f; 
}; 

void foo(int n, std::string s) { 
    std::cout << n << " " << s << std::endl; 
} 

int main() 
{ 
    Binder b(foo, 42, "test"); 
    b.callFunctionalObject(); 
} 

Se hai bisogno di qualcosa di più avanzato, potresti voler memorizzare la funzione argu in e std::tuple e quindi utilizzare alcuni modelli di magia per scartarlo, ma si prega di specificare che cosa esattamente avete bisogno nella domanda.

P.S. Vedi anche "unpacking" a tuple to call a matching function pointer

Answer 3

Il mio esempio:

// Indices 
template <std::size_t... Is> 
struct Indices {}; 

template <std::size_t N, std::size_t... Is> 
struct BuildIndices : BuildIndices <N - 1, N - 1, Is...> {}; 

template <std::size_t... Is> 
struct BuildIndices<0, Is...> : Indices <Is...> {}; 

template<class FuncObject, class ... T> 
class Binder 
{ 
public: 
    Binder(FuncObject funcObject, T... args) 
     : m_funcObject(funcObject), m_arguments(std::make_tuple(args...)) 
    { 
    } 

    void Call() 
    { 
     DoCall(BuildIndices<sizeof ... (T)> {}); 
    } 

private: 
    template<size_t... Ind> 
    void DoCall(Indices<Ind...>) 
    { 
     return m_funcObject(std::get<Ind>(m_arguments)...); 
    } 

    FuncObject m_funcObject; 
    std::tuple<T...> m_arguments; 
}; 

void Foo(int, char) 
{ 
} 

int main() 
{ 
    Binder<void(*)(int, char), int, char> f(Foo, 1, 'd'); 
    f.Call(); 

    return 0; 
}