Suppose you have the following:

假设您拥有以下内容：

Test.h

Test.h

class Test {
public:

    Test();
    // Other member variables
    void createThread();

}

Test.cpp

Test.cpp

void* threadRunnable(void* arg) {
// Uses Test class member variables
}

Test::Test(){
//
}

void Test::createThread() {

    pthread_create(..,threadRunnable,..);

}

How would the function threadRunnable passed into pthread_create be able to access member variables without instantiating an object? Or is this not possible.

传入pthread_create的函数threadRunnable如何在不实例化对象的情况下访问成员变量？或者这是不可能的。

Things I've tried:

我试过的东西：

• Singleton with a reference to the class (don't think this works as you still need an object first)


• Making the function threadRunnable a member or friend function

Not sure what else can be done

不知道还能做些什么

You'd need to supply the pointer to threadRunnable to pthread_create and also a pointer to this. Then cast arg to a Test*. I'm using NULL and a C style cast from void* to Test* instead of nullptr and a static_cast which will work in pre C++11:

你需要向pthread_create提供指向threadRunnable的指针，同时也提供指向this的指针。然后将arg转换为Test*。我使用了NULL和一个C风格的从void* 到Test* 的转换，而不是nullptr和一个static_cast，这将在C++11之前的版本中工作：

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

class Test {
public:
    ~Test() {
        pthread_join(th, NULL);
    }
    void createThread();

private:
    friend void* threadRunnable(void*);
    pthread_t th;
    int x;
};

void* threadRunnable(void* arg) { // <-----------+
    Test& tst = *((Test*)(arg)); // *this        |
    // Uses Test class member variables //       |
    tst.x = 10; //                               |
    std::cout << tst.x << '\n'; //               |
    return NULL; //                              |
} //                                             |
//                                               |
void Test::createThread() { //                   |
    pthread_create(&th, NULL, &threadRunnable, this);
}

int main() {
    Test tst;    
    tst.createThread();
}

A somewhat cleaner way that was often used before C++11 was to make threadRunnable a member function and to use a static proxy function with phtread_create:

在C++11之前经常使用的一种比较简洁的方法是使threadRunnable成为成员函数，并使用带有phtread_create的静态代理函数：

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

class Test {
public:
    ~Test() {
        pthread_join(th, NULL);
    }
    void createThread();

private:
    static void* runnableProxy(void*);
    void threadRunnable();
    pthread_t th;
    int x;
};

void* Test::runnableProxy(void* instance) {
    ((Test*)instance)->threadRunnable();
    return NULL;
}

void Test::threadRunnable() {
    // Uses Test class member variables
    x = 10;
    std::cout << x << '\n';
}

void Test::createThread() {
    pthread_create(&th, NULL, &Test::runnableProxy, this);
}

int main() {
    Test tst;    
    tst.createThread();
}

In modern C++ you'd use std::thread or std::jthread instead and then there's no need for a proxy function:

在现代C++中，您可以改用std：：Thress或std：：JThline，这样就不需要代理函数了：

Example:

示例：

#include <iostream>
#include <thread>

class Test {
public:
    void createThread();

private:
    void threadRunnable();
    std::jthread th;
    int x;
};

void Test::threadRunnable() {
    // Uses Test class member variables
    x = 10;
    std::cout << x << '\n';
}

void Test::createThread() {
    th = std::jthread(&Test::threadRunnable, this);
}

int main() {
    Test tst;
    tst.createThread();
}