template<class A,class B>
B&
operator,(A const&,B&b)throw()
{
  return(b);
}

PC>>Стандартный оператор возвращает a...

BF>

int i = 1, j = 2, k;
k = i, j;
cout << k;

class lock_resource{...};
...
lock_resource(X), X.do_something();

template < class T, class ctritical_section = Ваша_любимая >
//Ресурс разделяемый между потоками.
class shared_resource
{
  typedef shared_resource<T,ctritical_section> self;
  friend class lock<T,ctritical_section>;

  //Может предоставлять дополнительный сервис. см. ниже
  ctritical_section cs;

  //Важно при истинной паралельности. Процессоры не будут "драться".
  //Возможно лучше спрятать это внутри ctritical_section и обеспечить
  //STATIC_ASSERT(sizeof(ctritical_section)%processor_cache_line==0);
  //и размещение ctritical_section по адресам кратным processor_cache_line
  //ctritical_section и data не должны попадать в одну кэш-линию.
  char cache_align[processor_cache_line-1];

  //Без блокировки доступ к data крайне затруднён. Забыть lock невозможно.
  //Можно реализовать в виде private наследования.(учитывайте cache_align)
  //Возможно лучше использовать указатель ctritical_section* cs;
  T data;
  //А кому не лень может даже разложить всё это на стратегии.

public:
  //По умолчанию сгенериться не совсем то что надо.
  //(И зачем Страуструп эти умолчания сделал?)
  self& operator=(self const&);
  explicit//template конструктор НЕ является конструктором копий.
  shared_resource(self const&);
  //Да! lock это smart-pointer
  lock<T,ctritical_section> operator&();
  shared_resource();
  //Передадим аргументы конструктору T
  template<class A>
  explicit
  shared_resource(A const&);
  template<class A,class B>
  shared_resource(A const&,B const&);
  template<class A,class B,class C>
  shared_resource(A const&,B const&,C const&);
  ...
  //Можно и кучку operator-ов добавить.
  operator T()const;//а НЕ operator T const&()const;
  void swap(self&);//Может уменьшать вероятность dead-lock см. ниже
  self& operator=(T const&);
  //и т.д.
  ...
};

//Если конструктор ресурса T использует НЕ const ссылку используйте
template<class T>
class out_argument
{
  T& tmp;
public:
  operator T&() const throw()
    { return tmp; }
  explicit out_argument(T&src) throw()
    : tmp(src) {}
};

//Например если использовать конструктор you_class::you_class(std::istream&);
//то можно написать так:
shared_resource<you_class> object_name(out_argument(std::cin));
//А доступаться с блокировкой так:
(&object_name)->do_something();
access(object_name)->do_something();

template < class T, class ctritical_section = Ваша_любимая >
//Блокирует и предоставляет доступ к ресурсу.
class lock{
  shared_resource<T,ctritical_section>* ptr;
  //Не надо его по new ! Ещё delete забудете!
  void* operator new(size_t);
  //Попрячем это пока. Ежели понадобиться сделаем public
  //Опять же не будет лёгкой возможности lock в другой поток передать.
  //Вдруг я там просто счётчик инкрементирую. Ресурс то уже залочен.
  lock(lock const&);
  lock& operator=(lock const&);//Аналогично.
public:
  ~lock();//Забыть unlock невозможно. И throw не страшны.
  lock(shared_resource<T,ctritical_section>&);
  //Не вызывайте явно: T* ptr = access(X).operator->();
  //Не запоминайте указатель T*
  //Внутри T::any_method() не запоминайте this;
  T* operator->()const throw();
  T& operator* ()const throw();//Не запоминайте ссылку!
  //можно и так:
  lock& operator=(class non_complete*);//Снимем блокировку так: access_ptr=0;
  //далее кто как хочет и умеет:
  ...
};

//Ну и это для удобства. Не писать же везде lock<my_type>(my_object)
template<class T>
typename lock<T>
access(shared_resource<T>&src)
{
  return lock<T>(src);
}

void swap(T&a,T&b){
  //Важен одинаковый порядок блокировок.
  if(compare_critical_section_id(a,b){//ID могут быть просто адресами.
    std::swap(a,b);
  }else{
    std::swap(b,a);
  }
}

D_>class lock_resource{...};
D_>...
D_>lock_resource(X), X.do_something();
D_>

ACE_Thread_Mutex lock;
...
ACE_Guard< ACE_Thread_Mutex > scoped_guard< lock >;
// Твори с ресурсом все, что захочу.

Simplicity does not precede complexity, but follows it.

E_>ACE_Thread_Mutex lock;
E_>...
E_>ACE_Guard< ACE_Thread_Mutex > scoped_guard< lock >;
E_>// Твори с ресурсом все, что захочу.

ACE_Guard< ACE_Thread_Mutex > scoped_guard< lock >;

//Позволяет специализировать поведение для некоторых типов.
//В частности использовать interlocked_functions и т.д.
template < class T, class locker >
class shared_resource
{
//Позволяет использовать некоторые типы сторонних библиотек и встроенные типы.
  T data;
//Позволяет во время исполнения ассоциировать блокировщик для ресурса.
//и легко менять стратегии блокировок.
//(one_section \ section_per_class \ section_per_object \ mutex и т.д.
  locker* lock;
};

//Выбираем тип доступа только при использовании, а не при написании класса.
full_access(X)->do();
//Аналог const_cast
read_access(X)->do_const();//Это read-only блокировка
//Аналог static_cast
lock_base_only<base_X>(X)->base_X::non_virtual_method();
//Аналог dynamic_cast (в смысле наличия исключения)
access_with_exception<already_locked>(X)->do();
access_with_exception<time_expered>(X,12*second)->do();
//И даже аналог reinterpret_cast
access_without_lock(X)->do();

D_>ACE_Guard< ACE_Thread_Mutex > scoped_guard< lock >;
D_>

ACE_Guard< ACE_Thread_Mutex > scoped_guard( lock );

#undef SetWindowText
#define SetWindowText(x) SetWindowTextA("Я ВАС НЕНАВИЖУ")

#undef Sleep
#define Sleep(x) Sleep(x+1000)