模板有没有办法不用STL的萃取获得函数参数类型？

lonerwolf

RT

1. template<class T,class A1>
   
2. class A
   
3. {
   
4. public:
   
5.         A(void (T::*f)(A1), T* t,A1& a1):t_(t),f_(f)
   
6.         {
   
7.                 boost::bind(&A::operator(),this,_1);
   
8.         }
   
9. 
   
10.         void operator()(A1& a1)
    
11.         {
    
12.                 printf("asd\n");
    
13.                 (t_->*f_)(a1);
    
14.         }
    
15. 
    
16.         T* t_;
    
17.         void (T::*f_)(A1);
    
18. };
    
19. 
    
20. template<class T, class arg>
    
21. A<T,arg> ls_bind(void (T::*f)(arg), T* t,arg qwe)
    
22. {
    
23.         A<T,arg> a(f,t,qwe);
    
24.         return a;
    
25. }
    
26. 
    
27. class test
    
28. {
    
29. public:
    
30.         test()
    
31.         {
    
32. 
    
33.         }
    
34. 
    
35.         void close(int a)
    
36.         {
    
37.                 printf("%d\n",a);
    
38.         }
    
39. };
    
40. 
    
41. int main(int argc, char **argv)
    
42. {
    
43.         test qwe;
    
44.         boost::function<void(int)> f = ls_bind(&test::close,&qwe,3);
    
45.         f(2);
    
46.         return 0;
    
47. }
    

复制代码

给BIND的外覆了一层，但是有个地方不方便，ls_bind(&test::close,&qwe,3);必须要把第3个参数的类型传进去再行，能不能再修改一下，使得调用接口能够自动判断传进去的函数参数的类型以及个数？

lonerwolf

已解决

1. template<class T,class Arg1>
   
2. class Operation1
   
3. {
   
4.         typedef void (T::*F)(Arg1);
   
5. public:
   
6.         Operation1(F f,boost::shared_ptr<T>& sptT):f_(f),wpt_T_(sptT)
   
7.         {
   
8.                 boost::bind(&Operation1::operator(), this,_1);
   
9.         }
   
10. 
    
11.         void operator()(Arg1 arg1)
    
12.         {
    
13.                 boost::shared_ptr<T> spt_T = wpt_T_.lock();
    
14.                 if(spt_T)
    
15.                 {
    
16.                         T* p = spt_T.get();
    
17.                         (p->*f_)(arg1);
    
18.                 }
    
19.         }
    
20. 
    
21. private:
    
22.         F f_;
    
23.         boost::weak_ptr<T> wpt_T_;
    
24. };
    
25. 
    
26. template<class T,class Arg1,class Arg2>
    
27. class Operation2
    
28. {
    
29.         typedef void (T::*F)(Arg1,Arg2);
    
30. public:
    
31.         Operation2(F f,boost::shared_ptr<T>& sptT):f_(f),wpt_T_(sptT)
    
32.         {
    
33.                 boost::bind(&Operation2::operator(), this,_1,_2);
    
34.         }
    
35. 
    
36.         void operator()(Arg1 arg1,Arg2 arg2)
    
37.         {
    
38.                 boost::shared_ptr<T> spt_T = wpt_T_.lock();
    
39.                 if(spt_T)
    
40.                 {
    
41.                         T* p = spt_T.get();
    
42.                         (p->*f_)(arg1,arg2);
    
43.                 }
    
44.         }
    
45. 
    
46. private:
    
47.         F f_;
    
48.         boost::weak_ptr<T> wpt_T_;
    
49. };
    
50. 
    
51. template<class T, class Arg1>
    
52. Operation1<T,Arg1> ls_thread_safe_bind(void (T::*f)(Arg1), boost::shared_ptr<T>& sptT)
    
53. {
    
54.         Operation1<T,Arg1> operation(f,sptT);
    
55.         return operation;
    
56. }
    
57. 
    
58. template<class T, class Arg1, class Arg2>
    
59. Operation2<T,Arg1,Arg2> ls_thread_safe_bind(void (T::*f)(Arg1,Arg2), boost::shared_ptr<T>& sptT)
    
60. {
    
61.         Operation2<T,Arg1,Arg2> operation(f,sptT);
    
62.         return operation;
    
63. }
    
64. 
    
65. class A
    
66. {
    
67. public:
    
68.         A()
    
69. {
    
70. 
    
71. }
    
72.         void close(int a)
    
73.         {
    
74.                 printf("asd\n");
    
75.         }
    
76. 
    
77.         void close1(int a,bool b)
    
78.         {
    
79.                 printf("asd\n");
    
80.         }
    
81. };
    
82. 
    
83. int main()
    
84. {
    
85.         boost::shared_ptr<A> spt_a(new A());
    
86.         auto f = ls_thread_safe_bind(&A::close, spt_a);
    
87.         f(2);
    
88. 
    
89.         auto f1 = ls_thread_safe_bind(&A::close1, spt_a);
    
90.         f1(2,true);
    
91.         return 0;
    
92. }

复制代码

lonerwolf

难道就没有C++多线程的好书么？没什么好模式？只能靠自己手动保护逻辑？？？智能指针真TM是条贼船，上了就下不了，为了简单解决竞争用了weak_ptr,于是就要用上enable_shared_from_this,所有对象全要智能指针管理了。。。。估计后面还要做内存池。。。因为全是new智能指针

qinggeng

裸奔吧，然后上GC就好。