C++ 用于c++；_C++_Templates_C++11_Variadic Templates_G++ 4.7

C++ 用于c++；

c++ templates c++11

C++ 用于c++；,c++,templates,c++11,variadic-templates,g++-4.7,C++,Templates,C++11,Variadic Templates,G++ 4.7,这里我为c线程函数pthread\u create（）编写了一个线程包装器。它将允许对任何对象调用任何方法，并向该方法传递任意数量的参数。API是： template <typename T, typename R, typename... ATs> pthread_t NewThread(T *obj, R (T::*mem)(ATs...), ATs... args); 我希望我的输出是 yay my thread runs a=1234 x=3.14 Thread Ended

这里我为c线程函数

pthread\u create（）

编写了一个线程包装器。它将允许对任何对象调用任何方法，并向该方法传递任意数量的参数。API是：

template <typename T, typename R, typename... ATs>
pthread_t NewThread(T *obj, R (T::*mem)(ATs...), ATs... args);

我希望我的输出是

yay my thread runs a=1234 x=3.14
Thread Ended 139766222432000

那么这个

R (*function) (ATs...);

是函数指针，但需要成员函数指针

R (T::*function) (ATs...);

要调用成员函数指针，您需要一个对象，并且必须使用以下语法调用它：

self->*function(function_arguments...);

注意这里的语法

因此，我在

TupleUnpack:：unpack

中添加了一个

T*self

参数，并使用

obj

成员在

Call:：dispatch

中调用它。现在，我可以用

NewThread

中的

mem

参数替换

test

函数

这是一个补丁：

diff --git a/NewThread.hpp b/NewThread.hpp
index e121294..768f7d9 100644
--- a/NewThread.hpp
+++ b/NewThread.hpp
@@ -5,12 +5,12 @@ template<unsigned int i>
 class TupleUnpack 
 {
     public:
-    template<typename R, typename ...ATs, typename ...T_function_arguments>
-    inline static R unpack (R  (*function) (ATs...), 
+    template<typename T, typename R, typename ...ATs, typename ...T_function_arguments>
+    inline static R unpack (T* self, R (T::*function) (ATs...), 
     std::tuple<ATs...> arguments_tuple,
     T_function_arguments  ...function_arguments)
     {
-        return TupleUnpack<i-1>::unpack (function, arguments_tuple, std::get<i-1> (arguments_tuple), function_arguments...);
+        return TupleUnpack<i-1>::unpack (self, function, arguments_tuple, std::get<i-1> (arguments_tuple), function_arguments...);
     }                       
 };

@@ -18,12 +18,12 @@ template<>
 class TupleUnpack<0> 
 {
     public:
-    template<typename R, typename ...ATs, typename ...T_function_arguments>
-    inline static R unpack (R                (*function) (ATs...), 
+    template<typename T, typename R, typename ...ATs, typename ...T_function_arguments>
+    inline static R unpack (T* self, R (T::*function) (ATs...), 
     std::tuple<ATs...> arguments_tuple,
     T_function_arguments              ...function_arguments)
     {
-        return function (function_arguments...);
+        return (self->*function) (function_arguments...);
     }          
 };
 class CallCaller
@@ -35,19 +35,17 @@ template<typename T,typename R,typename ...ATs>
 class Call : public CallCaller
 {
     public:     
-    Call (T *obj,R (*function) (ATs...),ATs... arguments) :obj(obj),function (function),tuplearg (arguments...) {}
+    Call (T *obj,R (T::*function) (ATs...),ATs... arguments) :obj(obj),function (function),tuplearg (arguments...) {}

     ~Call() {}
     bool dispatch (void)
     {
-        return TupleUnpack<sizeof ...(ATs)>::unpack (this->function, this->tuplearg);
+        return TupleUnpack<sizeof ...(ATs)>::unpack(obj, this->function, this->tuplearg);
     }

     private:
     std::tuple<ATs...> tuplearg;
-    R (*function) (ATs...);
+    R (T::*function) (ATs...);

     T *obj;
 };
@@ -71,8 +69,7 @@ template <typename T, typename R, typename... ATs>
 pthread_t NewThread(T *ob, R (T::*mem)(ATs...), ATs... args)
 {
     pthread_t tid;
-    R (*func) (ATs...);
-    Call<T,R,ATs...> *task=new Call<T,R,ATs...>(ob,&test,args...);
+    Call<T,R,ATs...> *task=new Call<T,R,ATs...>(ob,mem,args...);

     pthread_create(&tid, nullptr, stub<T,R,ATs...>, task) ;

diff--git a/NewThread.hpp b/NewThread.hpp
索引e121294..768f7d9 100644
---a/NewThread.hpp
+++b/NewThread.hpp
@@-5,12+5,12@@template
类TupleUnpack
{
公众：
-模板
-内联静态R解包（R（*功能）（ATs…），
+模板
+内联静态R解包（T*self，R（T:：*功能）（ATs…），
std:：元组参数\u元组，
函数参数…函数参数）
{
-返回TupleUnpack:：unpack（函数，参数，std:：get（参数，参数），函数，参数…）；
+返回TupleUnpack:：unpack（self、function、arguments\u tuple、std:：get（arguments\u tuple）、function\u arguments…）；
}                       
};
@@-18,12+18,12@@template
类TupleUnpack
{
公众：
-模板
-内联静态R解包（R（*功能）（ATs…），
+模板
+内联静态R解包（T*self，R（T:：*功能）（ATs…），
std:：元组参数\u元组，
函数参数…函数参数）
{
-返回函数（函数参数…）；
+返回（self->*函数）（函数参数…）；
}          
};
类调用方
@@-35,19+35,17@@template
类调用：公共CallCaller
{
公众：
-调用（T*obj，R（*函数）（ATs…，ATs…参数）：obj（obj），函数（函数），TupleArguments…{}
+调用（T*obj，R（T:：*函数）（ATs…，ATs…参数）：obj（obj），函数（函数），tupleArguments…{}
~Call（）{}
布尔调度（无效）
{
-返回TupleUnpack:：unpack（this->function，this->tuplearg）；
+返回TupleUnpack:：unpack（obj，this->function，this->tuplearg）；
}
私人：
std:：tuple-tuplearg；
-R（*功能）（ATs…）；
+R（T:：*功能）（ATs…）；
T*obj；
};
@@-71,8+69,7@@template
pthread_t新线程（t*ob，R（t:：*mem）（ATs…，ATs…，args）
{
pthread_t tid；
-R（*func）（自动测试系统…）；
-Call*task=新呼叫（ob、测试和参数…）；
+Call*task=新呼叫（ob、mem、ARG…）；
pthread_创建（&tid，nullptr，stub，task）；

所以

R (*function) (ATs...);