类的成员函数怎么用std::thread

你可以使用`std::thread`在类的成员函数中创建一个线程。下面是一个示例：

#include <iostream>
#include <thread>

class MyClass {
public:
    void myFunction() {
        std::cout << "Hello from myFunction!" << std::endl;
    }
};

int main() {
    MyClass obj;
    std::thread t(&MyClass::myFunction, &obj);  // 创建一个线程，并指定类的成员函数及其对象
    t.join();  // 等待线程执行完毕
    return 0;
}

在上述示例中，`MyClass`包含了一个名为`myFunction`的成员函数。我们通过传递`&MyClass::myFunction`作为第一个参数，以及`&obj`作为第二个参数，创建了一个新的线程`t`。`&MyClass::myFunction`表示对`MyClass`中的成员函数的引用，而`&obj`表示对`obj`对象的引用。最后，我们使用`t.join()`等待线程执行完毕。

请注意，使用`std::thread`时，需要确保线程执行的函数在调用`join()`之前已经完成，否则可能会导致未定义的行为。

相关问题

错误：对‘std::thread::thread(<unresolved overloaded function type>)’的调用没有匹配的函数 std::thread reader_thread(readStream);

引用中的代码展示了一个在使用std::thread时出现的错误。错误信息是"no matching function for call to 'std::thread::thread(<unresolved overloaded function type>, A*, int)’"。这个错误是因为在将重载的函数放入std::thread的参数时，编译器无法匹配到正确的函数。

引用中的代码展示了另一种情况下的解决方案，使用了更优的方法。在这个例子中，定义了一个typedef来表示一个成员函数指针类型，然后通过将函数指针赋值给std::thread的参数来解决问题。

引用中的代码展示了另一种解决方案，通过强制类型转换来消除函数指针的歧义。在这种情况下，std::thread的参数中不再有隐式的this指针。

根据提供的信息，错误信息是"no matching function for call to 'std::thread::thread(<unresolved overloaded function type>)’"。从代码中可以看出，std::thread的构造函数调用了一个名为readStream的函数，但是由于函数的重载问题，编译器无法匹配到正确的函数。为了解决这个问题，可以参考引用和中的方法，使用typedef或强制类型转换来明确指定函数指针的类型。这样就可以避免函数重载引起的歧义，从而解决错误。

std::thread 绑定类成员函数

要在 std::thread 中绑定类成员函数，需要使用 std::bind 或者 lambda 表达式来创建一个可以调用的对象。

使用 std::bind 实现绑定类成员函数的示例如下：

#include <iostream>
#include <thread>
#include <functional>

class MyClass {
public:
    void memberFunction(int value) {
        std::cout << "Member function called with value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    int value = 42;

    // 使用 std::bind 绑定成员函数和对象
    std::thread myThread(std::bind(&MyClass::memberFunction, &obj, value));

    // 等待线程执行完毕
    myThread.join();

    return 0;
}

在上述示例中，我们首先创建了一个 MyClass 类，并在其中定义了一个成员函数 memberFunction。然后，在 main 函数中，我们创建了一个 MyClass 对象 obj 和一个值 value。接下来，使用 std::bind 将成员函数 memberFunction 绑定到 obj 上，并将 value 作为参数传递给成员函数。

最后，我们将绑定后的可调用对象传递给 std::thread 构造函数来创建线程对象 myThread，并使用 join() 等待线程执行完毕。

除了使用 std::bind，你还可以使用 lambda 表达式来绑定类成员函数。以下是使用 lambda 表达式的示例：

#include <iostream>
#include <thread>

class MyClass {
public:
    void memberFunction(int value) {
        std::cout << "Member function called with value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    int value = 42;

    // 使用 lambda 表达式绑定成员函数和对象
    std::thread myThread([&]() {
        obj.memberFunction(value);
    });

    // 等待线程执行完毕
    myThread.join();

    return 0;
}

在上述示例中，我们定义了一个 lambda 表达式，其中调用了成员函数 memberFunction，并传递了 value。然后，将 lambda 表达式传递给 std::thread 构造函数来创建线程对象 myThread，并使用 join() 等待线程执行完毕。

无论是使用 std::bind 还是 lambda 表达式，都可以实现将类成员函数绑定到 std::thread 中进行调用。选择使用哪种方式取决于个人偏好和特定的需求。