具有ptrhead的奇怪重复模板模式

Question

So I am trying to figure out if you can use curiously recurring template pattern to get around the limitations of pthread use with class methods and even class creation by doing some thing like.

template <class T>
class thread_helper
{
  static void* create(void *input)
  {
     T * output=new T;
     return static_cast<void*>(output);
  }

  static void* using(void *input)
  {
    T::use(input);
  }
};

class user : public thread_helper<user>
{
  void method(int x)
  {
    //does something
  }
  static void use(void* input)
  {
    this->method(static_cast<int>(input));
  }
};

Then you can use pthread to call class creation using

pthread_create(thread_variable, NULL, thread_helper::create<some_class>, void);

and for the other call

pthread_create(thread_variable, NULL, user::using(), void);

note:There are a lot of errors in the code above. Please don't rip me apart for them. I am really just trying to paint a picture of what I am trying to do. I am also trying to figure out if there is a better way of doing this operation.

Additionally is the second pthread_create method really necessary couldn't I just use the constructor one for that as well?

Answer 1

I am going to post a working test code. It involves a ton of boiler plate code. It is really ugly looking but works. Note: I will probably change thread_helper's create method at a later date so it cannot be used for threading.

#include <iostream>
#include "pthread.h"

using namespace std;

template <class I>
struct helper
{
    void *(I::*method)(void *); //enables you to call and get information from any non static class method
    I *ptr; //this is the class pointer used to call the member pointer
    void *info; //this is what you pass into the member pointer
};

template <class T>
class thread_helper
{
public:
    static void *create(void *in)
    {
        T * output=new T;
        return static_cast<void*>(output);
    }

    static void *method(void *in)
    {
        helper<T> *utilize = static_cast<helper<T> *>(in);
        return (utilize->ptr->*utilize->method)(utilize->info);
    }
};

class test: public thread_helper<test>
{
public:
    void *test_method(void *in)
    {
        int *val = (int *)in;//note: not static_casting since this is not a class
        *val *= 4;
        return val; //auto casts to void *
    }
};

int main()
{
    //initialize test
    test * second = static_cast<test*>(test::create(NULL));

    //initialize helper
    helper<test> first;
    first.ptr = second;
    first.method = &test::test_method;
    int val = 4;
    first.info = &val;//

    //setup threads
    pthread_t thread;
    void *ans;

    //call test_method and retrieve answer
    pthread_create(&thread, NULL, test::method, static_cast<void *>(&first));
    pthread_join(thread, &ans);

    cout << "the answer is "<< *(int *)ans <<endl;
    return 0;
}

As was pointed out this solution works if you are using pthreads. And is a generic replacement for writing either a function or a static method to call a class's methods.

If you are using boost or c++11 threads than this method is not needed and probably should not be used as it requires lots of boiler plate code(pointer casting).