เริ่มเธรดด้วยฟังก์ชันสมาชิก

ฉันพยายามที่จะสร้างที่มีฟังก์ชั่นสมาชิกที่เกิดการขัดแย้งใดและผลตอบแทนstd::thread voidฉันไม่สามารถหาไวยากรณ์ที่ใช้งานได้ - คอมไพเลอร์บ่นไม่ว่าจะเกิดอะไรขึ้น เป็นวิธีที่ถูกต้องในการใช้งานspawn()เพื่อให้ผลตอบแทนstd::threadที่ดำเนินการtest()คืออะไร?

#include <thread>
class blub {
  void test() {
  }
public:
  std::thread spawn() {
    return { test };
  }
};

#include <thread>
#include <iostream>

class bar {
public:
  void foo() {
    std::cout << "hello from member function" << std::endl;
  }
};

int main()
{
  std::thread t(&bar::foo, bar());
  t.join();
}

แก้ไข: บัญชีการแก้ไขของคุณคุณต้องทำเช่นนี้:

  std::thread spawn() {
    return std::thread(&blub::test, this);
  }

UPDATE:ฉันต้องการอธิบายเพิ่มเติมบางประเด็นบางส่วนถูกอภิปรายในความคิดเห็นด้วย

ไวยากรณ์ที่อธิบายไว้ข้างต้นมีการกำหนดในแง่ของนิยาม INVOKE (§20.8.2.1):

กำหนด INVOKE (f, t1, t2, ... , tN) ดังนี้:

• (t1. * f) (t2, ... , tN) เมื่อ f เป็นตัวชี้ไปยังฟังก์ชันสมาชิกของคลาส T และ t1 เป็นวัตถุประเภท T หรือการอ้างอิงไปยังวัตถุประเภท T หรือการอ้างอิงถึง วัตถุประเภทที่ได้มาจาก T;
• ((* t1). * f) (t2, ... , tN) เมื่อ f เป็นตัวชี้ไปยังฟังก์ชันสมาชิกของคลาส T และ t1 ไม่ใช่ประเภทที่อธิบายไว้ในรายการก่อนหน้า
• t1. * f เมื่อ N == 1 และ f เป็นตัวชี้ไปยังข้อมูลสมาชิกของคลาส T และ t 1 เป็นวัตถุประเภท T หรือการ
  อ้างอิงไปยังวัตถุประเภท T หรือการอ้างอิงไปยังวัตถุ
  ประเภทที่ได้มาจาก T;
• (* t1). * f เมื่อ N == 1 และ f เป็นตัวชี้ไปยังข้อมูลสมาชิกของคลาส T และ t 1 ไม่ใช่ประเภทที่อธิบายไว้ในรายการก่อนหน้า
• f (t1, t2, ... , tN) ในกรณีอื่นทั้งหมด

ข้อเท็จจริงทั่วไปอื่น ๆ ที่ฉันต้องการชี้ให้เห็นคือโดยค่าเริ่มต้นตัวสร้างเธรดจะคัดลอกอาร์กิวเมนต์ทั้งหมดที่ส่งผ่านไป เหตุผลของเรื่องนี้คือข้อโต้แย้งอาจต้องอยู่ได้นานกว่าการเรียกเธรดการคัดลอกข้อโต้แย้งรับประกันได้ว่า แต่ถ้าคุณต้องการจริงๆผ่านการอ้างอิงคุณสามารถใช้สร้างขึ้นโดยstd::reference_wrapperstd::ref

std::thread (foo, std::ref(arg1));

โดยการทำเช่นนี้คุณสัญญาว่าคุณจะดูแลการรับประกันว่าข้อโต้แย้งจะยังคงอยู่เมื่อเธรดดำเนินการกับพวกเขา

หมายเหตุว่าทุกสิ่งที่กล่าวข้างต้นนอกจากนี้ยังสามารถนำไปใช้และstd::asyncstd::bind

เนื่องจากคุณใช้ C ++ 11 แลมบ์ดานิพจน์เป็นคำตอบที่ดีและสะอาด

class blub {
    void test() {}
  public:
    std::thread spawn() {
      return std::thread( [this] { this->test(); } );
    }
};

เนื่องจากthis->สามารถละเว้นได้มันอาจย่อให้เหลือ:

std::thread( [this] { test(); } )

หรือเพียงแค่

std::thread( [=] { test(); } )

นี่คือตัวอย่างที่สมบูรณ์

#include <thread>
#include <iostream>

class Wrapper {
   public:
      void member1() {
          std::cout << "i am member1" << std::endl;
      }
      void member2(const char *arg1, unsigned arg2) {
          std::cout << "i am member2 and my first arg is (" << arg1 << ") and second arg is (" << arg2 << ")" << std::endl;
      }
      std::thread member1Thread() {
          return std::thread([=] { member1(); });
      }
      std::thread member2Thread(const char *arg1, unsigned arg2) {
          return std::thread([=] { member2(arg1, arg2); });
      }
};
int main(int argc, char **argv) {
   Wrapper *w = new Wrapper();
   std::thread tw1 = w->member1Thread();
   std::thread tw2 = w->member2Thread("hello", 100);
   tw1.join();
   tw2.join();
   return 0;
}

การคอมไพล์ด้วย g ++ สร้างผลลัพธ์ต่อไปนี้

g++ -Wall -std=c++11 hello.cc -o hello -pthread

i am member1
i am member2 and my first arg is (hello) and second arg is (100)

@ hop5 และ @RnMss แนะนำให้ใช้ lambdas C ++ 11 แต่ถ้าคุณจัดการกับพอยน์เตอร์คุณสามารถใช้โดยตรงได้:

#include <thread>
#include <iostream>

class CFoo {
  public:
    int m_i = 0;
    void bar() {
      ++m_i;
    }
};

int main() {
  CFoo foo;
  std::thread t1(&CFoo::bar, &foo);
  t1.join();
  std::thread t2(&CFoo::bar, &foo);
  t2.join();
  std::cout << foo.m_i << std::endl;
  return 0;
}

เอาท์พุท

2

ตัวอย่างที่เขียนซ้ำจากคำตอบนี้จะเป็น:

#include <thread>
#include <iostream>

class Wrapper {
  public:
      void member1() {
          std::cout << "i am member1" << std::endl;
      }
      void member2(const char *arg1, unsigned arg2) {
          std::cout << "i am member2 and my first arg is (" << arg1 << ") and second arg is (" << arg2 << ")" << std::endl;
      }
      std::thread member1Thread() {
          return std::thread(&Wrapper::member1, this);
      }
      std::thread member2Thread(const char *arg1, unsigned arg2) {
          return std::thread(&Wrapper::member2, this, arg1, arg2);
      }
};

int main() {
  Wrapper *w = new Wrapper();
  std::thread tw1 = w->member1Thread();
  tw1.join();
  std::thread tw2 = w->member2Thread("hello", 100);
  tw2.join();
  return 0;
}

ผู้ใช้บางคนได้รับคำตอบแล้วและอธิบายได้ดีมาก

ฉันต้องการเพิ่มสิ่งที่เกี่ยวข้องกับเธรดอีกไม่กี่รายการ

1. วิธีการทำงานกับ functor และเธรด โปรดดูตัวอย่างด้านล่าง

2. เธรดจะทำสำเนาวัตถุของตัวเองในขณะที่ผ่านวัตถุ

   #include<thread>
   #include<Windows.h>
   #include<iostream>
   
   using namespace std;
   
   class CB
   {
   
   public:
       CB()
       {
           cout << "this=" << this << endl;
       }
       void operator()();
   };
   
   void CB::operator()()
   {
       cout << "this=" << this << endl;
       for (int i = 0; i < 5; i++)
       {
           cout << "CB()=" << i << endl;
           Sleep(1000);
       }
   }
   
   void main()
   {
       CB obj;     // please note the address of obj.
   
       thread t(obj); // here obj will be passed by value 
                      //i.e. thread will make it own local copy of it.
                       // we can confirm it by matching the address of
                       //object printed in the constructor
                       // and address of the obj printed in the function
   
       t.join();
   }

อีกวิธีหนึ่งในการบรรลุเป้าหมายเดียวกันคือ:

void main()
{
    thread t((CB()));

    t.join();
}

แต่ถ้าคุณต้องการผ่านวัตถุโดยอ้างอิงแล้วใช้ไวยากรณ์ด้านล่าง:

void main()
{
    CB obj;
    //thread t(obj);
    thread t(std::ref(obj));
    t.join();
}