Comment créer une classe avec 2 threads à l'intérieur et un tableau de méthodes publiques qui ne sont pas dans ces threads? (C++, en utilisant des bibliothèques Boost)

Question

Donc je veux qu'une classe C++ contienne par exemple une fonction publique: int summ(); qui retournerait un int qui serait créé comme somme de 2 variables (chacune de ces variables devrait être éditée par un thread)

donc besoin d'un Généralement, je échantillon comme this:

#include <iostream> 
#include <boost/thread.hpp> 

namespace this_thread = boost::this_thread; 

int a = 0; 
int b = 0; 
int c = 0; 

class BaseThread 
{ 
public: 
    BaseThread() 
     { } 
    virtual ~BaseThread() 
     { } 

    void operator()() 
    { 
     try 
     { 
      for (;;) 
      { 
       // Check if the thread should be interrupted 
       this_thread::interruption_point(); 

       DoStuff(); 
      } 
     } 
     catch (boost::thread_interrupted) 
     { 
      // Thread end 
     } 
    } 

protected: 
    virtual void DoStuff() = 0; 
}; 

class ThreadA : public BaseThread 
{ 
protected: 
    virtual void DoStuff() 
    { 
     a += 1000; 
     // Sleep a little while (0.5 second) 
     this_thread::sleep(boost::posix_time::milliseconds(500)); 
    } 
}; 

class ThreadB : public BaseThread 
{ 
protected: 
    virtual void DoStuff() 
    { 
     b++; 
     // Sleep a little while (0.5 second) 
     this_thread::sleep(boost::posix_time::milliseconds(100)); 
    } 
}; 

int main() 
{ 
    ThreadA thread_a_instance; 
    ThreadB thread_b_instance; 

    boost::thread threadA = boost::thread(thread_a_instance); 
    boost::thread threadB = boost::thread(thread_b_instance); 

    // Do this for 10 seconds (0.25 seconds * 40 = 10 seconds) 
    for (int i = 0; i < 40; i++) 
    { 
     c = a + b; 
     std::cout << c << std::endl; 

     // Sleep a little while (0.25 second) 
     this_thread::sleep(boost::posix_time::milliseconds(250)); 
    } 

    threadB.interrupt(); 
    threadB.join(); 

    threadA.interrupt(); 
    threadA.join(); 
} 

mais somme devrait pas programm mais dans une classe que notre programme principal serait capable de créer et d'obtenir ce summ() en cas de besoin.

Comment faire une telle chose?

Answer 1

L'exemple est un peu étrange, car les résultats seraient aléatoires, en fonction de la coordination exacte des threads et des temps de sommeil. Cependant, pour obtenir ce que vous voulez, vous avez plusieurs options. Vous pouvez créer une nouvelle classe avec:

• Le code de votre fonction principale en tant que méthode de classe; La variable c (somme) serait un membre de classe;
• Le code de la méthode retournera la somme.

Quelque chose comme:

class TwoThreads 
{ 
    int sum; 

public: 
    int doSomething() 
    { 
     // Same code as in main, using "sum" as the accumulator variable 
     return sum; 
    } 
};