Call wrapper con funzione C++ con funzione come argomento modello

Question

Sto tentando di creare una funzione generica wrapper che accetta una funzione come argomento modello e accetta gli stessi argomenti di quella funzione dei suoi argomenti. Ad esempio:

template <typename F, F func> 
/* return type of F */ wrapper(Ts... Args /* not sure how to get Ts*/) 
{ 
    // do stuff 
    auto ret = F(std::forward<Ts>(args)...); 
    // do some other stuff 
    return ret; 
} 

La soluzione deve essere colabile a un puntatore funzione con lo stesso tipo func modo che possa passare ad un'api C. In altre parole, la soluzione deve essere una funzione e non un oggetto funzione. Ancora più importante, Devo essere in grado di lavorare nella funzione wrapper.

Se i commenti inline non sono chiare, mi piacerebbe essere in grado di fare qualcosa di simile al seguente:

struct c_api_interface { 
    int (*func_a)(int, int); 
    int (*func_b)(char, char, char); 
}; 

int foo(int a, int b) 
{ 
    return a + b; 
} 

int bar(char a, char b, char c) 
{ 
    return a + b * c; 
} 

c_api_interface my_interface; 
my_interface.func_a = wrapper<foo>; 
my_interface.func_b = wrapper<bar>; 

ho cercato related posts e trovato questi, ma nessuno di loro sono abbastanza quello Sto cercando di fare. La maggior parte di questi post riguarda oggetti funzionali. Quello che sto cercando di fare è anche possibile?

Function passed as template argument

Function wrapper via (function object) class (variadic) template

How does wrapping a function pointer and function object work in generic code?

How do I get the argument types of a function pointer in a variadic template class?

Generic functor for functions with any argument list

C++ Functors - and their uses

In risposta alle prime 2 risposte, ho modificato la domanda per chiarire che devo essere in grado di lavorare nella funzione wrapper (ad es. modificare alcune stato globale prima e dopo la chiamata alla funzione avvolto)

Answer 1

#include <utility> 
#include <iostream> 

struct c_api_interface { int (*func_a)(int, int); int (*func_b)(char, char, char); }; 
int foo(int a, int b) { return a + b; } 
int bar(char a, char b, char c) { return a + b * c; } 


template<typename Fn, Fn fn, typename... Args> 
typename std::result_of<Fn(Args...)>::type 
wrapper(Args... args) { 
    std::cout << "and ....it's a wrap "; 
    return fn(std::forward<Args>(args)...); 
} 
#define WRAPIT(FUNC) wrapper<decltype(&FUNC), &FUNC> 

int main() { 
    c_api_interface my_interface; 
    my_interface.func_a = WRAPIT(foo); 
    my_interface.func_b = WRAPIT(bar); 

    std:: cout << my_interface.func_a(1,1) << std::endl; 
    std:: cout << my_interface.func_b('a','b', 1) << std::endl; 

    return 0; 
} 

vedere http://rextester.com/ZZD18334

Answer 2

probabilmente bisogno di qualcosa come

template <typename F> 
class Wrapper { 
public: 
    Wrapper(F *func) : function(func) {} 
    operator F*() { return function; } 
    F *function; 
}; 

che si può usare come void (*funcPtr)(int) = Wrapper<void(int)>(&someFunction);

Answer 3

penso che sarà il modo conciso di fare ciò che si vuole:

template <typename F> 
F* wrapper(F* pFunc) 
{ 
    return pFunc; 
} 

e usarlo in questo modo:

my_interface.func_a = wrapper(foo); 
my_interface.func_a(1, 3); 

Answer 4

template<class F, F f> struct wrapper_impl; 
template<class R, class... Args, R(*f)(Args...)> 
struct wrapper_impl<R(*)(Args...), f> { 
    static R wrap(Args... args) { 
     // stuff 
     return f(args...); 
    } 
}; 

template<class F, F f> 
constexpr auto wrapper = wrapper_impl<F, f>::wrap; 

Utilizzare come wrapper<decltype(&foo), foo>.

Answer 5

si può provare qualcosa di simile (brutto, ma funziona)

#include <iostream> 
#include <functional> 

struct wrapper_ctx 
{ 
    wrapper_ctx() 
    { 
    std::cout << "Before" << std::endl; 
    } 
    ~wrapper_ctx() 
    { 
    std::cout << "after" << std::endl; 
    } 
}; 

template <typename F, typename... Args> 
auto executor (F&& f, Args&&... args) -> typename std::result_of<F(Args...)>::type 
{ 
    wrapper_ctx ctx; 
    return std::forward<F>(f)(std::forward<Args>(args)...); 

} 

template <typename F> 
class wrapper_helper; 


template<typename Ret, typename... Args> 
class wrapper_helper <std::function<Ret(Args...)>> 
{ 
    std::function<Ret(Args...)> m_f; 
public: 
    wrapper_helper(std::function<Ret(Args...)> f) 
     : m_f(f) {} 
    Ret operator()(Args... args) const 
    { 
    return executor (m_f, args...); 
    } 
}; 

template <typename T> 
wrapper_helper<T> wrapper (T f) 
{ 
    return wrapper_helper <T>(f); 
} 


int sum(int x, int y) 
{ 
    return x + y; 
} 


int main (int argc, char* argv []) 
{ 

    std::function<int(int, int)> f = sum; 
    auto w = wrapper (f); 

    std::cout << "Executing the wrapper" << std::endl; 
    int z = w(3, 4); 

    std::cout << "z = " << z << std::endl; 
}