Dfyjkt

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
 
 
;