如何在不同的线程中调用同一类的多个对象的方法？

Question

我在C小白++，并有一个类（mystack），有一个在它的方法（推），它可以使用

mystack a; 
a.push(); 

现在我已经创造了A类的多个实例调用，并为他们每个人我想调用push方法，我想知道如何在不同的线程中调用它们，谢谢。

---

编辑

完整的代码如下（这是很长，但很简单明了），有类mystack的两个实例，他们每个人提方法调用的顺序，我要让方法在不同的线程中调用不同的实例，所以我想在一个线程中执行实例stc的push和pop操作，并且在另一个线程中执行stc2中的相同操作，那么我将如何实现这一点？

#include "stdafx.h" 
#include <string> 
#include <iostream> 
#include <thread> 
#include <vector> 
#include <mutex> 

using namespace std; 

//static recursive_mutex mtx; 

struct mystack 
{ 
    int *p; 
    unsigned int limit, counter; 

public: 
    unsigned int max() 
    { 
     return limit; 
    } 

    ~mystack() 
    { 
     delete p; 
    } 

    mystack(int k) : limit(k), p(0), counter(0) 
    { 
     if (limit > 0) 
     { 
      p = new int[limit]; 
     } 
    } 

    void push(unsigned int k) 
    { 
     if (counter >= limit) 
     { 
      throw 1; 
     } 

     p[counter] = k; 
     counter++; 
    } 

    int pop() 
    { 
     if (counter <= 0) 
     { 
      throw 1; 
     } 

     counter--; 

     return p[counter]; 
    } 
}; 

int main(int, char*[]) 
{ 
    mystack stc(5); 
    try 
    { 
     stc.push(1); 
     stc.push(2); 
     stc.push(3); 
     stc.push(4); 
     stc.push(5); 
     stc.push(6); 
    } 
    catch (int i) 
    { 
     try 
     { 
      cout << "pop out the values" << endl; 
      while (true) 
      { 
       cout << stc.pop() << " "; 
      } 
     } 
     catch (int j) 
     { 
      cout << endl; 
      cout << "stack is now empty" << endl; 
      cout << endl; 
     } 
    } 


    mystack stc2(3); 
    try 
    { 
     stc2.push(1); 
     stc2.push(2); 
     stc2.push(3); 
     stc2.push(4); 
     stc2.push(5); 
     stc2.push(6); 
    } 
    catch (int i) 
    { 
     try 
     { 
      cout << "pop out the values" << endl; 
      while (true) 
      { 
       cout << stc2.pop() << " "; 
      } 
     } 
     catch (int j) 
     { 
      cout << endl; 
      cout << "stack is now empty" << endl; 
      cout << endl; 
     } 
    } 

    return 0; 
} 

Answer 1

你问了一个相当普遍的问题，但假设你没有已创建还没有任何线程，使用C++ 11和std ::线程将是你最好的选择：

#include <iostream> 
#include <thread> 

struct A 
{ 
    int id; 
    A(int i) : id(i) {} 

    void push() { 
     std::cout << id << " pushin." << std::endl; 
    } 
}; 

A obj_a(0); 
void push_global() {obj_a.push();} 

void push_an_A(A& obj) {obj.push();} 

int main() 
{ 
    A obj_b(1), 
     obj_c(2); 

    // globals (not recommended) 
    std::thread thread_a(push_global); 

    // using lambdas 
    auto push_b = [&obj_b](){ 
     obj_b.push(); 
    }; 

    std::thread thread_b(push_b); 

    // binding 
    std::thread thread_c(std::bind(push_an_A, obj_c)); 

    thread_a.join(); 
    thread_b.join(); 
    thread_c.join(); 
} 

请记住使用您的编译器的等效-std=c++11和-pthread选项。

编辑：为您更新的代码，（尽管奇使用异常流量控制对那里发生的），这是因为考虑你正在做的操作顺序和功能把它们插简单：

void do_sequence(mystack &stack) 
{ 
    try 
    { 
     stack.push(1); 
     stack.push(2); 
     stack.push(3); 
     stack.push(4); 
     stack.push(5); 
     stack.push(6); 
    } 
    catch (int i) 
    { 
     try 
     { 
      cout << "pop out the values" << endl; 
      while (true) 
      { 
       cout << stack.pop() << " "; 
      } 
     } 
     catch (int j) 
     { 
      cout << endl; 
      cout << "stack is now empty" << endl; 
      cout << endl; 
     } 
    } 
} 

int main(int, char*[]) 
{ 
    mystack stc(5), 
     stc2(3); 

    // note that we need to use std::ref() so that the arguments are correctly 
    // passed by reference, otherwise we get memory corruption 
    std::thread thread_stc(std::bind(do_sequence, std::ref(stc))), 
     thread_stc2(std::bind(do_sequence, std::ref(stc2))); 

    thread_stc.join(); 
    thread_stc2.join(); 

    return 0; 
}