Здравствуйте, Acteon, Вы писали:

A>>>Подход 6. Потерялось наследование Concreate от Base.
К>>Не потерялось. Base и Concrete — финальные классы.

A>Все, увидел. Оно просто реализуется через myself(). Я правильно понял?
Ага. Это, чтобы уменьшить количество писанины — static_cast<Final*>(this) всюду не вставлять.


A>Да, увидел, понял. А то что Concrete дружит с классом BaseT<Base> вместо BaseT<Concrete> просто ошибка.
Дык, я "с листа" писал, поторопился


К>>Но хотя бы boost:: / std::tr1:: bind можно использовать?

A>Нет. Проект уже давний, на чем пишут, на том пишут. Но уже раз десять сталкивался с тем, что приходилось писать велосипеды, т.к. в Qt нет того, что есть в бусте. Даже элементарный non_copyable реализован не так как надо.

В смысле, пишут для старого компилятора?
Прицепить бустовские header-only библиотеки можно безболезненно к чему угодно.


К>>template<class Fun> struct FunThread: Thread \\ Ошибочка.
И снова поторопился


A>И получится уже что-то близкое к бустовским потокам. Это уже 11-й раз. За идею спасибо.

Можно не тащить весь boost::bind, а нашлёпать заготовки биндингов самых расхожих. Ну там,
(void(*)()) — из свободной функции без параметров
(void(*)(Arg),Arg) — из функции с одним параметром
(void(Class::*)(),Class*) — из функции-члена класса
(void(Class::*)(Arg),Class*,Arg) — из функции-члена с дополнительным параметром
Чтобы потом потоки рожать сразу на месте, без классов.

template<class Fun, class Arg> struct bind_fun1_t
{
  Fun m_fun;
  Arg m_arg;
  bind_fun1_t(Fun fun, Arg arg) : m_fun(fun), m_arg(arg) {}
  void operator()() { m_fun(m_arg); }
};
template<class Obj, class Mem> struct bind_mem0_t
{
  Obj* m_obj;
  Mem m_mem;
  bind_mem0_t(Obj* obj, Mem mem) : m_obj(obj), m_mem(mem) {}
  void operator()() { (m_obj->*m_mem)(); }
};
template<class Obj, class Mem, class Arg> struct bind_mem1_t
{
  Obj* m_obj;
  Mem m_mem;
  Arg m_arg;
  bind_mem0_t(Obj* obj, Mem mem, Arg arg) : m_obj(obj), m_mem(mem), m_arg(arg) {}
  void operator()() { (m_obj->*m_mem)(arg); }
};

template<class F>                   F                  bindf(F f)           { return                   (f);     } // тривиально
template<class F, class A>          bind_fun1_t<F,A>   bindf(F f, A a)      { return bind_fun1_t<F,A>  (f,a);   }
template<class O, class M>          bind_mem0_t<O,M>   bindm(O*o, M m)      { return bind_mem0_t<O,M>  (o,m);   }
template<class O, class M, class A> bind_mem1_t<O,M,A> bindm(O*o, M m, A a) { return bind_mem1_t<O,M,A>(o,m,a); }