Hi folks,

To better understand the "future" concept, I am looking at the following code and have several questions:
(1) I got a compiling warning: 'this' : used in base member initializer list. How can I get rid of it?
(2) how can I bind class's local data x_ into the new thread? I tried:   t_(boost::bind(&future<T>::run, this, x_) ), but it does not work.
(3) There seems a race condition in the overloaded function call operator()(). What wrong did I do?

BTW: if the future is constructed as ctor using:
          future(boost::function<T ()> const& f);
the code snippet works with minor modification.

Thanks in advance,

Cheers,
Robert
====== code snippet =====
#include <boost/bind.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/function.hpp>

template<typename T>
class future : boost::noncopyable
{
public:
    future(boost::function<T (int)> const& f, int);
    T operator()();
private:
        int x_;
        bool joined_;
        T v_;
        boost::function<T (int)> const& f_;
        boost::mutex m_;
        void run();
        boost::thread t_;
};

template<typename T>
future<T>::future(boost::function<T (int)>const& f, int x) : x_(x), joined_(false), v_(T()), f_(f), t_(boost::bind(&future<T>::run, this) ) { }

template<typename T>
T future<T>::operator()()
{
        mutex::scoped_lock lock(m_);
        if (!joined_) {
            t_.join();
            joined_ = true;
        }
        return v_;
}

template<typename T>
void future<T>::run()
{
    v_ = f_(x_);
}