Vfrdtyky

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?

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);
   
   

   
   

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

        }

    }

};