使用std :: thread从C ++ 11中的两个类调用函数

Question

I am trying to implement an API that should let the user create two communication channels in parallel. One channel uses TCP and the other uses UDP. I have two classes representing the two channels. These classes have different functions implemented. I would like the functions from the two channels to run in parallel. For that I am using std::thread to create two threads, one for each channel (class). The idea is the following following The header file looks like

class Channel_1
{
public:
     int myfunc(int a, int b);
};

class Channel_2
{
public:
    int anotherfunc(int a, int b);
};

In the main cpp file include the header file

int main()
{
  int a = 10, b = 20;
  Channel_1 ch1;
  Channel_2 ch2;

  std::thread t(ch1.myfunc, a,b);
  return 0;
}

I get the error saying that no instance of the constructor std::thread exists.

I have the following questions.

1. Can't we call the functions from a class in the thread constructor?
2. Does this idea of using threads for calling functions from different classes make sense?

Answer 1

You actually have two problems:

1. The syntax is wrong. You need to pass a pointer to the member function, as in

    std::thread t(&Channel_1::myfunc, a, b); 

2. Non-static member functions needs to be called on an instance of the class. This instance must be passed as the first argument:

    std::thread t(&Channel_1::myfunc, ch1, a, b); 

Answer 2

As Some programmer dude said, you need to supply a pointer to the function (either a static or non-static). A third option could be to make a base class that implements a start() method that uses this thread constructor:

template< class Function, class... Args > 
explicit thread( Function&& f, Args&&... args );

Example using a lambda. It's not meant to be a complete working example, It's only meant to show how the third thread constructor could be used.

class thread_base {
private:
    std::thread m_th;
    bool m_terminated;

    void proxy() {
        // in the new thread
        // add thread_base setup here if needed and
        // call the execute() method in the derived class
        execute();
    }
public:
    thread_base() : m_th(), m_terminated(false) {}
    thread_base(const thread_base&) = delete;
    thread_base& operator=(const thread_base&) = delete;
    thread_base(thread_base&&) = default;
    thread_base& operator=(thread_base&&) = default;
    virtual ~thread_base() { join(); }

    virtual void start() {
        if(joinable()) throw std::runtime_error("thread already running");
        else m_th = std::thread( [this] { proxy(); } );
    }

    inline bool joinable() { return m_th.joinable(); }
    inline void join() { if(joinable()) { m_th.join(); m_terminated=false; } }
    inline void terminate() { m_terminated=true; }
    inline bool terminated() { return m_terminated; }

    virtual void execute() = 0; // implement this in your derived classes
};


class Channel_1 : public thread_base {
    void execute() {
        // runs in a thread
        // with a volontary check if a soft termination
        // request has been issued
        while( !terminated() ) {
            // work
        }
    }
};