C++ - Funktionsaufruf-Wrapper mit Funktion als Vorlageargument

Question

Ich versuche, eine generische Wrapperfunktion zu erstellen, die eine Funktion als Vorlageargument übernimmt und dieselben Argumente wie diese Funktion als Argumente verwendet. Zum Beispiel:

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; 
} 

Die Lösung muss gießbaren auf einen Funktionszeiger mit dem gleichen Typ wie func sein, so dass ich es an einen C api passieren kann. Mit anderen Worten, die Lösung muss eine Funktion und kein Funktionsobjekt sein. Am wichtigsten ist, Ich muss in der Lage sein, Arbeit in der Wrapper-Funktion zu tun.

Wenn die Inline-Kommentare nicht klar sind, würde ich das so etwas wie die Lage sein, gerne tun folgende:

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>; 

ich für verwandte Beiträge gesucht und gefunden diese, aber keiner von ihnen ist ganz das, was Ich versuche es zu tun. Die meisten dieser Posts betreffen Funktionsobjekte. Ist das, was ich versuche, überhaupt möglich?

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

Als Antwort auf die ersten beiden Antworten habe ich die Frage bearbeitet, um klarzustellen, dass ich in der Lage sein muss, in der Wrapper-Funktion zu arbeiten (d. H. ändern einige globalen Zustand vor und nach dem Aufruf der eingewickelt Funktion)

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; 
} 

siehe http://rextester.com/ZZD18334

Answer 2

Sie wahrscheinlich so etwas wie

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

benötigen, die Sie mögen void (*funcPtr)(int) = Wrapper<void(int)>(&someFunction);

Answer 3

denken verwenden kann ich, dass wird die prägnante Art und Weise zu tun, was Sie wollen:

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

und es wie folgt verwendet werden:

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; 

Verwendung als wrapper<decltype(&foo), foo>.

Answer 5

man so etwas versuchen kann (hässlich, aber funktioniert)

#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; 
}