A melhor maneira de iniciar uma discussão como um membro de uma classe C ++?

Question

Eu estou querendo saber o melhor maneira de começar um pthread que é um membro de uma classe C ++? Minha própria abordagem segue como uma resposta ...

Answer 1

Eu costumo usar uma função membro estático da classe, e usar um ponteiro para a classe como parâmetro void *. Essa função pode então realizar o processamento de fio, ou chamar uma outra função de membro não-estático com a referência de classe. Essa função pode fazer referência a todos os membros da classe sem sintaxe estranho.

Answer 2

Isto pode ser feito simplesmente usando a biblioteca de impulso, como este:

#include <boost/thread.hpp>

// define class to model or control a particular kind of widget
class cWidget
{
public:
void Run();
}

// construct an instance of the widget modeller or controller
cWidget theWidget;

// start new thread by invoking method run on theWidget instance

boost::thread* pThread = new boost::thread(
    &cWidget::Run,      // pointer to member function to execute in thread
    &theWidget);        // pointer to instance of class

Notas:

• Este usa uma função de membro de classe comum. Não há necessidade de adicionar extra, membros estáticos que confundem sua interface de classe
• Apenas incluem boost / thread.hpp no ??arquivo de origem onde você começa o segmento. Se você está apenas começando com impulso, todo o resto desse pacote grande e intimidante pode ser ignorado.

Em C ++ 11 você pode fazer o mesmo, mas sem impulso

// define class to model or control a particular kind of widget
class cWidget
{
public:
void Run();
}

// construct an instance of the widget modeller or controller
cWidget theWidget;

// start new thread by invoking method run on theWidget instance

std::thread * pThread = new std::thread(
    &cWidget::Run,      // pointer to member function to execute in thread
    &theWidget);        // pointer to instance of class

Answer 3

Você tem que inicializar-lo usando o parâmetro void *:

class A
{
  static void* StaticThreadProc(void *arg)
  {
    return reinterpret_cast<A*>(arg)->ThreadProc();
  }

  void* ThreadProc(void)
  {
    // do stuff
  }
};

...

pthread_t theThread;
pthread_create(&theThread, NULL, &A::StaticThreadProc, this);

Answer 4

eu usei três dos métodos descritos acima. Quando usei pela primeira vez enfiar no c ++ Eu costumava funções de membro estático , em seguida, funções friend e, finalmente, os bibliotecas Boost . Atualmente eu prefiro impulso. Ao longo dos últimos anos eu me tornei muito pelo fanático impulso.

REFORÇO é C ++ como CPAN é Perl. :)

Answer 5

A biblioteca de impulso fornece um mecanismo de cópia, o que ajuda a transferir informações de objeto ao novo segmento. Em outro exemplo impulso impulso :: bind irá ser copiada com um ponteiro, o qual também é apenas copiado. Então você vai ter que tomar cuidado para a validade do seu objeto para impedir que um apontador pendente. Se você implementar o operador () e fornecer um construtor de cópia em vez e passar o objeto diretamente, você não precisa se preocupar com isso.

Uma solução mais agradável tanto, o que impede um monte de problemas:

#include <boost/thread.hpp>

class MyClass {
public:
        MyClass(int i);
        MyClass(const MyClass& myClass);  // Copy-Constructor
        void operator()() const;          // entry point for the new thread

        virtual void doSomething();       // Now you can use virtual functions

private:
        int i;                            // and also fields very easily
};

---

MyClass clazz(1);
// Passing the object directly will create a copy internally
// Now you don't have to worry about the validity of the clazz object above
// after starting the other thread
// The operator() will be executed for the new thread.
boost::thread thread(clazz);             // create the object on the stack

O outro exemplo impulso cria o objeto de discussão na pilha, embora não haja nenhum sentido fazê-lo.