C++ 使用pthread_create从线程调用类成员函数

下面是代码

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

using namespace std;

class Base

{
    private:
    public:

        void *threadCall1( void * value)
        {
            cout<<"inside threadCall1"<<endl;

        }

    protected:

};

class Derived
{
    private:
    public:
        void  *threadCall2 ();
    protected:



};


 void *Derived::threadCall2()
{
    cout<<"inside threadCall2"<<endl;

}
int main ()
{
    int k = 2;
    pthread_t t1;
    cout<<"inside main"<<endl;
    Base *b = new Base();

    pthread_create(&t1,NULL,&b->threadCall1,(void *)k);

    return 0;
}

#包括
#包括
使用名称空间std；
阶级基础
{
私人：
公众：
void*threadCall1（void*value）
{
cout没有
&b->threadCall1
这样的东西。幸运的是，pthread允许您将一个空ptr传递给类（用k填充的类）。将
b
作为这个空ptr传递给一个全局（或静态成员）函数，该函数只调用
b->threadCall1（）
然后将k移动到Base的属性，而不是Base:：threadCall1（）的参数。
没有
&b->threadCall1
这样的东西。幸运的是，pthread允许您将一个空ptr传递给类（您正在填充k的类）。将
b
作为这个空ptr传递给全局（或静态成员）只调用
b->threadCall1（）；
的函数，然后将k移到Base的属性，而不是Base:：threadCall1（）的参数。
可以通过相应地分派工作的函数执行此操作：

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

struct Base {
    virtual void work() {
        std::cout << "Base::work()\n";
    }

    virtual ~Base() {}
};

struct Derived : public Base {
    void work() override {
        std::cout << "Derived::work()\n";
    }
};

void* thread_adapter(void* obj) {
    Base* p = static_cast<Base*>(obj);
    p->work();
    return nullptr;
}

int main() {
    Derived d;
    pthread_t thread;
    pthread_create(&thread, nullptr, thread_adapter, &d);
    pthread_join(thread, nullptr);
}

您可以通过相应地分派工作的功能来执行此操作：

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

struct Base {
    virtual void work() {
        std::cout << "Base::work()\n";
    }

    virtual ~Base() {}
};

struct Derived : public Base {
    void work() override {
        std::cout << "Derived::work()\n";
    }
};

void* thread_adapter(void* obj) {
    Base* p = static_cast<Base*>(obj);
    p->work();
    return nullptr;
}

int main() {
    Derived d;
    pthread_t thread;
    pthread_create(&thread, nullptr, thread_adapter, &d);
    pthread_join(thread, nullptr);
}

 
不能使用指针到成员函数作为线程例程。考虑使用AD上下文结构将需要信息传递给Tead AD例程：

struct thread_context {
  Base* object;
  void (Base::*func)(void*);
};

void *thread_routine(void *arg) {
   thread_context* context = static_cast<thread_context*>(arg);
   context->object->(*context->func)(nullptr);
   ...
}

...
thread_context context = {
   b1,
   &Base::threadCall1
};
pthread_create(&t1,NULL,&thead_routine, &context);

struct-thread\u上下文{
基本*对象；
无效（基数：：*func）（无效*）；
};
void*thread_例程（void*arg）{
线程上下文*上下文=静态线程转换（arg）；
上下文->对象->（*上下文->函数）（空ptr）；
...
}
...
线程\u上下文={
b1，
&Base:：threadCall1
};
pthread_create（&t1，NULL，&thead_例程，&context）；
< /代码> 不能使用指针到成员函数作为线程例程。考虑使用AD上下文结构将需要信息传递给Tead AD例程：

struct thread_context {
  Base* object;
  void (Base::*func)(void*);
};

void *thread_routine(void *arg) {
   thread_context* context = static_cast<thread_context*>(arg);
   context->object->(*context->func)(nullptr);
   ...
}

...
thread_context context = {
   b1,
   &Base::threadCall1
};
pthread_create(&t1,NULL,&thead_routine, &context);

struct-thread\u上下文{
基本*对象；
无效（基数：：*func）（无效*）；
};
void*thread_例程（void*arg）{
线程上下文*上下文=静态线程转换（arg）；
上下文->对象->（*上下文->函数）（空ptr）；
...
}
...
线程\u上下文={
b1，
&Base:：threadCall1
};
pthread_create（&t1，NULL，&thead_例程，&context）；
不允许，你不能这样做。POSIX线程对C++一无所知。为什么不使用STD:：线程？我是说，不能直接地直接调用DI。当然，你可以从POSIX兼容的线程回调中调用你的成员函数。不，你不能这样做。POSIX线程对C++一无所知。为什么不使用STD:：线程？我的意思是，不能直接DI。当然，你可以调用MEM。来自Posix兼容线程回调的ber函数。