Trình bao bọc hàm chức năng C++ với chức năng làm đối số mẫu

Question

Tôi đang cố gắng tạo hàm bao hàm chung có chức năng làm đối số mẫu và lấy các đối số giống như hàm đó làm đối số của nó. Ví dụ:

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

Các giải pháp cần phải được cast cho một con trỏ hàm với cùng loại như func để tôi có thể vượt qua nó để một api C. Nói cách khác, giải pháp cần phải là một hàm và không phải là một đối tượng hàm. Quan trọng nhất, Tôi cần để có thể làm việc trong hàm wrapper.

Nếu các ý kiến ​​inline không rõ ràng, tôi muốn để có thể làm điều gì đó như sau:

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

Tôi nhìn cho bài viết có liên quan và phát hiện này, nhưng không ai trong số họ là khá gì Tôi đang cố gắng làm. Hầu hết các bài viết này đều liên quan đến các đối tượng hàm. Là những gì tôi đang cố gắng làm thậm chí có thể?

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

Để trả lời 2 câu trả lời đầu tiên, tôi đã chỉnh sửa câu hỏi để làm rõ rằng tôi cần có khả năng làm việc trong hàm bao bọc (tức là sửa đổi một số trạng thái toàn cầu trước và sau khi gọi hàm bọc)

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

thấy http://rextester.com/ZZD18334

Answer 2

có thể bạn cần một cái gì đó giống như

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

Mà bạn có thể sử dụng như void (*funcPtr)(int) = Wrapper<void(int)>(&someFunction);

Answer 3

tôi nghĩ rằng sẽ là cách súc tích để làm những gì bạn muốn:

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

và sử dụng nó như thế này:

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; 

Sử dụng làm wrapper<decltype(&foo), foo>.

Answer 5

bạn có thể thử một cái gì đó như thế (Ugly, nhưng hoạt động)

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