K>>>мне кажется что объект-поток должен отвечать только за корректный запуск и остановку потока. А "чтоб при его убийстве у тя не было ликов (памяти, дескрипторов, и еще черт знает чего)" это не его проблеммы, а проблеммы разработчика самой потоковой функции. Ведь системной _beginthreadex это тоже по барабану

Z>>корректный с чьей точки зрения? -- системы наплевавшей на кучу объектов нуждающихся в нетривиальном удалении?

Z>>такой подход тоже имеет право на существование -- вот поэтому мне и не нравятся бустерные threadы (и многие другие библы по сути являющиеся wapperами (разной степени корявости) над системными Сишными функциями)

Z>>разумееца программер должен следить за кучей всего в своей проге (вместа того чтоб сконцентрироватся над задачей ) -- но это не наш way

int foo(int, const std::string&) { ... }
...
thread_wrapper thr(&foo);
thr.start(10, "sample string");

void my_threaded_function(...)
{
    ...
    MyMegaObjectWithDestructor obj(...);
    some_mutex.lock();
    ...
    some_mutex.unlock();
    ...
}

Z>передать то можно и эот даже хорошо! но есть одна маленькая проблемка: в функтор еще нужно передеать параметры -- подумай вот над чем:

Z>int foo(int, const std::string&) { ... }
Z>...
Z>thread_wrapper thr(&foo);
Z>thr.start(10, "sample string");
Z>

Z>как реализовать start?

class Caller : public ICaller {
private :
    boost::function <unsigned (void *)> m_func;

    Caller (const Caller&);
    Caller& operator = (const Caller&);

public :
    template <class T>
    Caller (T& obj, unsigned (T::*func)(void *))
        : m_func (boost::bind (func, &obj, _1)) {;}
    explicit Caller (unsigned (*func)(void *)) : m_func (func) {;}
    virtual ~Caller () {;}
    virtual unsigned call (void* arg) const
    {
        return m_func (arg);
    }

};

class Thread : virtual public BaseThread {
private:

        void* m_arg;
    boost::shared_ptr<ICaller> m_caller;

    Thread (const Thread&);
    Thread& operator = (const Thread&);

    virtual unsigned execute (void)
        {
            return m_caller->call (m_arg);
        }

public:
    template <class T>
    Thread (T& obj, unsigned (T::*func)(void *), void* arg)
        : m_caller (new Caller (obj, func)), m_arg (arg) {;}
    virtual ~Thread ();
};

Z>ну это зависит от реализации -- причем ТВОЕЙ

Z>void my_threaded_function(...)
Z>{
Z>    ...
Z>    MyMegaObjectWithDestructor obj(...);
Z>    some_mutex.lock();
Z>    ...
Z>    some_mutex.unlock();
Z>    ...
Z>}
Z>

template <class BaseLock>
class Locker {

private :
    const BaseLock& m_lock;

    Locker (const Locker&);
    Locker operator = (const Locker&);

public :
    explicit Locker (const BaseLock& lock) : m_lock (lock)
    {
        m_lock.lock();
    }
    ~Locker ()
    {
        m_lock.unlock();
    }

};

class Mutex : public BaseLock {
private :
    HANDLE m_hMutex;

    Mutex (const Mutex&);
    Mutex& operator = (const Mutex&);

public :
    virtual bool lock (void) const;
    virtual bool unlock (void) const;

};

void my_threaded_function(...)
{
    ...
    MyMegaObjectWithDestructor obj(...);
    Locker<Mutex> lock (m_mutex);
    ...
}

Z>>интересно ктойта тебе пообещал вызвать деструктор??

Z>>твой thread умрет (!!) еще в конструкторе твоего Locker'a! -- и как уже было сказано не получит управления в зад (чтобы вызвать какиебы то ни было деструкторы!

K>ну чесно говоря — это спорный вопрос. Если система захотела убить вообще весь процес — аминь (это уж Билл пусть заботиться о безопасности)

void worker_thread(...)
{
    MyObjectWithDestructor obj(...);
    ...
    // в этой функции чтото долго и упорно вычисляется (или просто ктото притормаживает)
    // таким образом возникает timeout и worker_scheduler решает ее замочить...
    very_long_time_calculations_here();
    ...
}

void worker_scheduler(...)
{
    while (ходим по списку запущеных обработчиков)
    {
        ...
        if (текущий обработчик задержатся с вычислениями)
            // убиваем голубчика! результат уже никому не нужен...
            worker_threads[i].join();
        ...
    }
}

>> У меня в доморошенном потоке в joine стоит некое разумное время завершения, после чего прога поток заверщает и ругается на мои кривые руки правда это токо в дебаг режиме ...

...
thr.cancel();          // say 'DIE' to thread...
thr.join();            // wait for thread death...
...