warp an input function with variadic-parameter into member function - c++

Question

What I want to do is design a class that can execute a function asynchronously. I need warp it in member function, because I want to know whether it complete or not.
The basic design is the following:
struct SelectionAsynMission
{
template<typename Function, typename...Args>
void start(Function && f, Args&&...a)
{
// compiler failed here
thread_.swap(thread(std::bind(&SelectionAsynMission::execute_warp<Function, Args ...>, this), f,std::forward<Args>(a)...));
//thread_.swap(std::thread(f, std::forward<Args>(a)...)); no warp work fine
thread_.detach();
}
template<typename Function, typename...Args>
void execute_warp(Function && f, Args&& ... a)
{
thread_complete_ = false;
f(std::forward<Args>(a)...);
thread_complete_ = true;
}
void join();
atomic<bool> thread_complete_; // Use atomic to tell the main thread whether it is complete.
thread thread_;
};
The Compile Error is:
error C2064: term does not evaluate to a function taking 1 arguments
So any suggestion for the design to fulfill the requirement
Or ideas about fix the compile error would be helpful.
Thank you for your help, I was stupid enough to forget the basic of std::bind.
Before see your comments and answers
I have tried another way to do this. I use async to warp the function, and instead the atomic, i use future status to determine whether the job complete. I wasn't sure which cost more time, read atomic or future status, but the future status seems easier.
template<class Function, class...Args>
void start(Function && f, Args&... a)
{
// start the function with async
future_node_ = std::async(std::launch::async,f,std::forward<Args&>(a)...);
}
bool iscomplete()
{
// wait for zero time to get status.
auto status = future_node_.wait_for(std::chrono::nanoseconds(0));
// determine whether the job is done
return status == std::future_status::ready;
}

Answer 1

Well, you have kind of a skeleton of something usable. But the error is pretty obvious if you look where the error is coming from:
std::thread(std::bind(member_fn, this), fn, args...)
You're trying to pass arguments to a function object returned from a std::bind that doesn't take any arguments.
What you want to do is pretty hard using std::bind, because it requires the std::placeholders constructs _1, _2, _3, etc, etc to signal that there are _n many args to be passed. That would require some template trickery.
A better option would be to use a lambda expression; a feature of C++11, which you are probably using seeing as though you make use of std::thread which is another C++11 feature.
Here's how to do it using lambdas:
class myclass{
template<typename Func, typename ... Args>
void start(Func &&f, Args &&... args){
m_thread.swap(std::thread{
[this](Func &&f, Args &&... uargs){
this->execute_warp(std::forward<Func>(f), std::forward<Args>(uargs)...);
},
std::forward<Func>(f), std::forward<Args>(args)...
});
m_thread.detach();
}
template<typename Func, typename ... Args>
void execute_warp(Func &&f, Args &&... args){
m_thread_done = false;
f(std::forward<Args>(args)...);
m_thread_done = true;
}
void join(){
while(!m_thread_done.load(std::memory_order_relaxed)){}
}
std::atomic<bool> m_thread_done;
std::thread m_thread;
}
And I might add a way to do it using std::bind to my answer.