C++ 在C++；

因此，我尝试线程化一个成员函数，但同时使用一个类的两个不同对象（每个对象都有一个初始化为不同值的变量）。如果我想在类中传递成员函数，我知道如何使用多线程，例如：

class ClassA{

public:
void func{}
}

int main{

thread t1(&ClassA func);
thread t2(&ClassA func);
}

在引用类下的特定对象时，是否有方法使用多线程？我在网上找不到与此问题相关的任何内容

例如，我们有：

class ClassA{

public:
ClassA(sf::texture tex) : sprite(tex){};
void func(){
//does sth with sprite for this object
}
private:
sf::sprite sprite;
};

int main{
ClassA class1(tex1);
ClassA class2(tex2);

//thread t1(&ClassA func, What should go here?)
//thread t2(&ClassA func, What should go here?)
}

---

我想分别调用class1和class2的func，这样它们都可以使用自己的初始化tex。

有两种方法可以真正做到这一点

我更喜欢lambda方法，它允许您添加一些有时不属于

func

的必要复杂性：

#include <thread>

class ClassA {
 public:
  ClassA(const char* c) : c_(c){};
  void func() {
    // Do thing.
  }

 private:
  const char* c_;
};

int main(int argc, char* argv[]) {
  ClassA obj1("HELLO");
  ClassA obj2("WORLD");

  std::thread t1([&obj1]() { obj1.func(); });
  std::thread t2([&obj2]() { obj2.func(); });

  t1.join();
  t2.join();
}

#包括
甲级{
公众：
ClassA（const char*c）：c_u3;（c）{}；
void func（）{
//做点什么。
}
私人：
const char*c；
};
int main（int argc，char*argv[]）{
A类obj1（“你好”）；
A类obj2（“世界”）；
std：：线程t1（[&obj1]（）{obj1.func（）；}）；
线程t2（[&obj2]（）{obj2.func（）；}）；
t1.join（）；
t2.连接（）；
}

但也有指向成员函数的指针方法：

#include <thread>

class ClassA {
 public:
  ClassA(const char* c) : c_(c) {};
  void func() {
    // Do thing.
  }

 private:
  const char* c_;
};

int main(int argc, char* argv[]) {
  ClassA obj1("HELLO");
  ClassA obj2("WORLD");

  std::thread t1(&ClassA::func, &obj1);
  std::thread t2(&ClassA::func, &obj2);

  t1.join();
  t2.join();
}

#包括
甲级{
公众：
ClassA（const char*c）：c_u3;（c）{}；
void func（）{
//做点什么。
}
私人：
const char*c；
};
int main（int argc，char*argv[]）{
A类obj1（“你好”）；
A类obj2（“世界”）；
std:：线程t1（&ClassA:：func和&obj1）；
std：：线程t2（&ClassA：：func和&obj2）；
t1.join（）；
t2.连接（）；
}

自C++11以来，可以使用函数和成员函数的包装器。与

std:：bind

一起，您可以得到“某物”，它表示已绑定到特定对象的成员函数，以及（可选）其他参数：

class MyClass {
public:

    void printX() const { cout << x << endl; };
    int x;
};

int main(){

    MyClass mco1 {1}, mco2 {2};

    auto f = std::bind(&MyClass::printX, &mco1);
    std::thread t1 (f);

    f = std::bind(&MyClass::printX, &mco2);
    std::thread t2 (f);


    t1.join();
    t2.join();

}

class-MyClass{
公众：
void printX（）常量{这可能会有帮助：使用
std:：bind
的可能重复没有错，但通常会首选lambda。@super：在这个具体示例中，lambda比绑定函数有什么优势？性能是一个原因。可读性和不易出错，但这更多是一种观点。在中讨论了。因此在具体的例子是，除了偏好之外，可能没有区别。