scoped_lock(x)->f();

scoped_lock<X>(x)->f();
scoped_lock<Y>(y)->g();

struct X
{
    void f(){}
    boost::detail::lightweight_mutex mtx_;
};

struct Y
{
    void g(){}
    boost::detail::lightweight_mutex mtx_;
};

int main()
{
    X x;
    lock(x)->f();

    Y y;
    lock(y)->g();
}

#include <boost/detail/lightweight_mutex.hpp>
#include <boost/optional.hpp>
#include <boost/utility/in_place_factory.hpp>
#include <boost/ref.hpp>

typedef boost::optional<boost::detail::lightweight_mutex::scoped_lock> lock_storage;

template<typename T>
T* lock(T& obj, lock_storage const& lock = lock_storage())
{
    const_cast<lock_storage&>(lock) = boost::in_place(boost::ref(obj.mtx_));
    return &obj;
}

template<typename T>
T* lock(T& obj, lock_storage<T> const& lock = lock_storage<T>())
{
    const_cast<lock_storage<T>&>(lock) = boost::in_place(boost::ref(obj.mtx_));
    return &obj;
}

B>>>Мне кажется, необходимость наличия в защищаемом классе открытого члена mtx_ несколько огланичивает область применения такой обертки.

class sync
{
  boost::mutex mtx_;
  friend ...;
};

struct X : sync
{
  // ...
};

struct Y : sync
{
  // ...
};

AS>>>>Ну, тоже вариант, в принципе. Может, даже более интересный за счет явного указания намерений. Вот только клиенту придется явно указывать тип этого прокси, ведь порождающую функцию тут применить нельзя по тем же самым причинам. А хотелось бы избежать лишних телодвижений. Библиотечный код пишется один раз, а вот пользуются им гораздо чаще

R>>http://gzip.rsdn.ru/forum/message/2937445.1.aspx

Автор: remark
Дата: 04.05.08

template<typename T>
struct lazy_storage
{
public:
  lazy_storage()
    : init_()
  {
  }
  
  ~lazy_storage()
  {
    if (init_)
      reinterpret_cast<T*>(buf)->~T();
  }

protected:
  union
  {
    char buf [sizeof T];
    TYPE_WITH_MAX_ALIGNMENT fake; // __int64
  };
  bool init_;
};

struct lock_storage : lazy_storage<scoped_lock>
{
  void construct(mutex& m)
  {
    assert(false == init_);
    new (buf) scoped_lock (m);
    init_ = true;
  }
};

template<typename T>
T* lock(T& obj, lock_storage const& storage = lock_storage())
{
  storage.construct(obj.mtx_);
  return &obj;
}

Foo const& temp_foo( ....., Foo const& temp = Foo() ) // создаётся вызывающей стороной
{
    .....
    return temp;
}

Foo const& temp_foo( ....., optional<Foo> const& temp = optional<Foo>() ) // размещается вызывающей стороной,
{
    remove_const(temp) = in_place(.....); // а создаётся функцией
    return temp;
}

Bar apropos_foo(Bar bar, optional<Foo> const& temp = optional<Foo>() )
{
    .....
    return bar;
}

(scoped_lock(x.mtx_), x).member();

T& lock(T& obj, scoped_lock const& lk = scoped_lock(obj.mtx_))
{
  return obj;
}

lock(x).member();

К>Foo& temp_foo( ....., Foo const& temp = Foo() ) // создаётся вызывающей стороной
К>{
К>    .....
К>    return const_cast<Foo&>(temp);
К>}
К>

template<size_t sz>
struct buf_t
{
  mutable char data [sz];
};

char* foo(buf_t<64> const& buf = buf_t<64>())
{
  // отъели немного стека во фрейме вызывающей функции
  // ...
  return (char*)buf;
}

char* foo(void* buf = alloca(64))
{
  // отъели немного стека во фрейме вызывающей функции
  // память будет жить до конца вызывающей функции
  return strcpy((char*)buf, "Hello from dead!");
}

int main()
{
    char* str = foo();
    printf("%s", str);
    // магия: str никаким образом удалять не надо - вся строка у нас на стеке
}

К>Foo const& temp_foo( ....., optional<Foo> const& temp = optional<Foo>() ) // размещается вызывающей стороной,
К>{
К>    remove_const(temp) = in_place(.....); // а создаётся функцией
К>    return temp;
К>}
К>

К>Bar apropos_foo(Bar bar, optional<Foo> const& temp = optional<Foo>() )
К>{
К>    .....
К>    return bar;
К>}
К>

К>(scoped_lock(x.mtx_), x).member();
К>

К>T& lock(T& obj, scoped_lock const& lk = scoped_lock(obj.mtx_))
К>{
К>  return obj;
К>}
К>

К>lock(x).member();
К>

template <class T>
struct dyn_array_t {
  dyn_array_t(void* abuf, size_t n) :
    buf(static_cast<T*>(abuf)), n(n) {
    for (T* cur = buf, *end = buf + n; cur != end; ++cur)
      new(cur) T();
  }
  ~dyn_array_t() {
    for (T* cur = buf, *end = buf + n; cur != end; ++cur)
      cur->~T();
  }
  T& operator[](size_t i) {return buf[i];}
  private:
    T* buf;
    size_t n;
    dyn_array_t(const dyn_array_t&);
    const dyn_array_t& operator==(const dyn_array_t&);
};
#define init_dyn_array(T, Name, N) dyn_array_t<T> Name(alloca(sizeof(T) * N), N)

struct my_struct_t {
  int a, b;
};

void foo(size_t n) {
  init_dyn_array(my_struct_t, my, n);
  for (int i = 0; i < n; ++i)
    my[i].a = n - (my[i].b = i);
  for (int i = 0; i < n; ++i)
    printf("%d, %d", my[i].a, my[i].b);
}

int main() {
  foo(64);
}

boost::in_place(boost::ref(obj.mtx_));

class A 
{
    mutex mtx_;

    friend A* lock<>(A& obj, lock_storage const&);
};

R>class sync
R>{
R>  boost::mutex mtx_;
R>  friend ...;
R>};

R>struct X : sync
R>{
R>  // ...
R>};

R>struct Y : sync
R>{
R>  // ...
R>};
R>

lock<X>(x)->f();

AS>А теперь представим, что массив аллоцируют в цикле... Лучше так не эмулировать

void f()
{
  alloca(1);
}

void g()
{
  for (int i = 0; i != 1000000; ++i)
    f();
}