函数指针使用c++类成员函数

使用一些C的库时，需要让类的成员函数对接C的回调函数指针。
以pthread为例，利用类里的一个静态函数作为pthread_create的参数，将类的this指针传给这个静态函数，然后就可以想干什么干什么了。

点击(此处)折叠或打开

1. template <typename A, typename R>
   
2. class thr: public boost::noncopyable
   
3. {
   
4. private:
   
5.     typedef A arg_t;
   
6.     typedef R res_t;
   
7.     typedef pthread_t tid_t;
   
8.     typedef boost::function func_t;
   
9.     thr(){}
   
10.     tid_t _tid;
    
11.     arg_t _arg;
    
12.     res_t _res;
    
13.     func_t _func;
    
14. 
    
15.     static void* _thread_func(void* arg)
    
16.     {
    
17.         ((thr*)arg)->func();
    
18.         return NULL;
    
19.     }
    
20. public:
    
21.     explicit thr(func_t func, arg_t arg): _func(func), _arg(arg){}
    
22.     ~thr(){}
    
23.     tid_t get_tid() {return _tid;}
    
24.     arg_t get_arg() {return _arg;}
    
25.     res_t get_result() {return _res;}
    
26.     void set_arg(arg_t arg) {_arg = arg;}
    
27.     void set_result(res_t res){_res = res;}
    
28. 
    
29.     void func() {_res = _func(_arg);}
    
30.     int run() {return pthread_create(&_tid, NULL, _thread_func, this);}
    
31.     int join()
    
32.     {
    
33.         void* p;
    
34.         return pthread_join(_tid, &p);
    
35.     }
    
36. };
    
37. 
    
38. class test
    
39. {
    
40. public:
    
41.     char* f(int i)
    
42.     {
    
43.         char* s = new char[10];
    
44.         sprintf(s, "%d", i);
    
45.         return s;
    
46.     }
    
47. };
    
48. 
    
49. int main()
    
50. {
    
51.     test te;
    
52.     thr th(boost::bind(&test::f, te, _1), 123);
    
53.     th.run();
    
54.     th.join();
    
55. 
    
56.     char* s = th.get_result();
    
57.     cout << th.get_result() << endl;
    
58.     delete[] s;
    
59.     return 0;
    
60. }

上面为了方便用了boost::function。使得整个类和boost::thread功能有点重复。

如果不想用boost，可以想下面这样，用继承的方式。

class thr

{

protected:

    pthread_t _tid;

    static void* _thread_func(void* arg) {return ((thr*)arg)->_func();}

    virtual void* _func() = 0;

    thr(const thr& o){}

public:

    thr(){}

    ~thr(){}

    int start_thread()

    {

        int re = pthread_create(&_tid, NULL, _thread_func, this);

        if(re != 0) return re;

    }

    int join_thread()

    {

        void* p;

        if(pthread_join(_tid, &p) != 0) return -1;

        cout << (*(int*)p) << endl;

        return 0;

    }

};

class test : public thr

{

private:

    int _i;

    void* _func()

    {

        cout << "thread begin" << endl;

        return &_i;

    }

public:

    test(int i):_i(i){}

};

int main()

{

    test te(10);

    te.start_thread();

    te.join_thread();

    return 0;

}

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/26239116/viewspace-2123701/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/26239116/viewspace-2123701/