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;
}

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();
К>

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();

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

class A 
{
    mutex mtx_;

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

AS>Ну а куда деваться... Есть множество библиотек, где гварды реализованы именно как некопируемые объекты. Приходится извращаться

class synchronized
{
  mutex mtx;
  friend class lock;
  ...
};

class lock
{
  noncopyable_scoped_lock l_;
  lock(synchronized&)
  ...
};

class user_class : public synchronized
{
};

int main()
{
  user_class x;
  lock l (x);
  //...
}

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;
}

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);
}

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

void f()
{
  alloca(1);
}

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

class Foo
{
public:
    void foo() NOT_EXCLUSIVE;
    void bar() EXCLUSIVE;
};

.....
Foo x;
x.foo(); // ok
x.bar(); // error
locked(x).bar(); // ok

R>>>>Ну твой вариант 2 — это вообще неработающий хак...

2. Сделать нечто вроде move ctor:

template <class T>
struct any_holder
{
    operator void *()
    {
        return value;
    }
    char value[sizeof(T)];
};

struct CX1
{
    CX1(boost::detail::lightweight_mutex &mutex):bLocked(true)
    {
        new (m_guard) boost::detail::lightweight_mutex::scoped_lock(mutex);
    }
    ~CX1()
    {
        if (bLocked)
        {
            static_cast<boost::detail::lightweight_mutex::scoped_lock *>((void *)m_guard)->~scoped_lock();
        }

    }
    CX1 (CX1 &other):bLocked(true)
    {
        other.bLocked = false;
    }
private:
    CX1 & operator =(const CX1 &);
    any_holder<boost::detail::lightweight_mutex::scoped_lock> m_guard;
    bool bLocked;
};

AS>С чего бы это вдруг ссылка стала равна указателю? В данном случае максимум, что надо, макс алигн добавить. А вообще, как я уже говорил, даже 6-ка сворачивает этот код в полностью inline, никакого там копирования нет и не будет в прицнипе Эта реализация фактически остается для совсем дубовых компиляторов.

R>>>>От варианта 1 отличается тем, что будет работать и без RVO, и пользователь не попадёт в ситуацию, когда ему линкер вдруг выдаёт непонятную ошибку. А когда пользователь поймёт, что за ошибка, то исправлять её не понятно как... если он, конечно, не читал топик "[Trick] Call wrapper"

lock(x).f();
lock(y).g();

class A
{
    mutex mtx_;
    
    void a();
    void b();
    void c();

public:
    class Lock;
    friend class Lock;

    class Lock
    {
        mutex::lock guard_;
        A& a_;
    public:
        explicit Lock(A& a): guard_(a.mtx_), a_(a) {}

        void a() { a_.a(); }
        void b() { a_.b(); }
        void c() { a_.c(); }
    };
};

class Counted { public: void AddRef(); void Release(); };
class Base: public Counted {};
class ABase: public Base {};
class A: public ABase {};

A aInst;

// заблокировать aInst один раз и подергать его методы 
{
    A::Lock l(aInst);
    l.a();
    l.b();
}

// заблокировать aInst столько раз, сколько методов вызвано
A::Lock(aInst).a();
A::Lock(aInst).b();
}

К>class Foo
К>{
К>public:
К>    void foo() NOT_EXCLUSIVE;
К>    void bar() EXCLUSIVE;
К>};

К>.....
К>Foo x;
К>x.foo(); // ok
К>x.bar(); // error
К>locked(x).bar(); // ok
К>

back
empty
front
pop
push
size

pop
push

crypto/async_tx/async_tx.c
drivers/block/brd.c
drivers/char/ipmi/ipmi_msghandler.c
drivers/char/tty_io.c
drivers/input/evdev.c
drivers/input/input.c
drivers/input/joydev.c
drivers/input/mousedev.c
drivers/md/multipath.c
drivers/md/raid1.c
drivers/md/raid10.c
drivers/md/raid5.c
drivers/net/bonding/bond_main.c
drivers/net/hamradio/bpqether.c
drivers/net/macvlan.c
drivers/net/wan/lapbether.c
drivers/net/wan/syncppp.c
drivers/net/wireless/strip.c
drivers/parisc/led.c
drivers/s390/net/qeth_main.c
fs/afs/security.c
fs/binfmt_elf.c
fs/binfmt_elf_fdpic.c
fs/compat.c
fs/dcache.c
fs/dnotify.c
fs/exec.c
fs/ext4/mballoc.c
fs/fcntl.c
fs/file_table.c
fs/ioprio.c
fs/nfs/delegation.c
fs/nfs/nfs4proc.c
fs/proc/array.c
fs/proc/base.c
fs/proc/proc_net.c
fs/proc/root.c
fs/select.c
include/linux/inetdevice.h
include/linux/list.h
include/linux/netfilter.h
include/linux/netpoll.h
include/linux/nsproxy.h
include/linux/pid.h
include/linux/radix-tree.h
include/linux/rcuclassic.h
include/linux/rcupdate.h
include/linux/rcupreempt.h
include/linux/sched.h
include/linux/srcu.h
include/net/addrconf.h
include/net/netdma.h
include/net/sock.h
include/net/xfrm.h
ipc/msg.c
ipc/util.c
ipc/util.h
kernel/acct.c
kernel/auditfilter.c
kernel/auditsc.c
kernel/audit_tree.c
kernel/cgroup.c
kernel/cgroup_debug.c
kernel/cpuset.c
kernel/exit.c
kernel/fork.c
kernel/futex.c
kernel/notifier.c
kernel/pid.c
kernel/posix-cpu-timers.c
kernel/rcuclassic.c
kernel/rcupdate.c
kernel/rcupreempt.c
kernel/rcutorture.c
kernel/rtmutex-debug.c
kernel/sched.c
kernel/sched_debug.c
kernel/sched_fair.c
kernel/signal.c
kernel/srcu.c
kernel/sys.c
kernel/taskstats.c
kernel/timer.c
kernel/tsacct.c
lib/proportions.c
lib/radix-tree.c
lib/textsearch.c
mm/memcontrol.c
mm/migrate.c
mm/page-writeback.c
mm/readahead.c
mm/rmap.c
mm/slab.c
net/802/psnap.c
net/8021q/vlan_dev.c
net/atm/clip.c
net/bridge/br_fdb.c
net/bridge/br_forward.c
net/bridge/br_input.c
net/bridge/br_ioctl.c
net/bridge/br_stp_bpdu.c
net/can/af_can.c
net/can/proc.c
net/core/dev.c
net/core/fib_rules.c
net/core/filter.c
net/core/gen_estimator.c
net/core/netpoll.c
net/core/pktgen.c
net/core/rtnetlink.c
net/decnet/dn_neigh.c
net/decnet/dn_route.c
net/decnet/dn_table.c
net/econet/af_econet.c
net/ipv4/af_inet.c
net/ipv4/arp.c
net/ipv4/cipso_ipv4.c
net/ipv4/devinet.c
net/ipv4/fib_frontend.c
net/ipv4/fib_trie.c
net/ipv4/icmp.c
net/ipv4/ipmr.c
net/ipv4/ip_input.c
net/ipv4/netfilter/ipt_REDIRECT.c
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c
net/ipv4/netfilter/nf_conntrack_proto_icmp.c
net/ipv4/netfilter/nf_nat_core.c
net/ipv4/route.c
net/ipv4/tcp_cong.c
net/ipv6/addrconf.c
net/ipv6/addrlabel.c
net/ipv6/af_inet6.c
net/ipv6/anycast.c
net/ipv6/icmp.c
net/ipv6/ip6_fib.c
net/ipv6/ip6_input.c
net/ipv6/ipv6_sockglue.c
net/ipv6/mcast.c
net/ipv6/ndisc.c
net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
net/ipv6/reassembly.c
net/irda/irlan/irlan_client.c
net/irda/irlan/irlan_common.c
net/irda/irlan/irlan_eth.c
net/mac80211/ieee80211.c
net/mac80211/ieee80211_sta.c
net/mac80211/rx.c
net/mac80211/tx.c
net/mac80211/util.c
net/netfilter/core.c
net/netfilter/nfnetlink_queue.c
net/netfilter/nf_conntrack_core.c
net/netfilter/nf_conntrack_expect.c
net/netfilter/nf_conntrack_extend.c
net/netfilter/nf_conntrack_h323_main.c
net/netfilter/nf_conntrack_netbios_ns.c
net/netfilter/nf_conntrack_netlink.c
net/netfilter/nf_conntrack_pptp.c
net/netfilter/nf_conntrack_proto.c
net/netfilter/nf_conntrack_standalone.c
net/netfilter/nf_log.c
net/netfilter/nf_queue.c
net/netfilter/xt_connlimit.c
net/netfilter/xt_helper.c
net/netlabel/netlabel_cipso_v4.c
net/netlabel/netlabel_domainhash.c
net/netlabel/netlabel_kapi.c
net/netlabel/netlabel_mgmt.c
net/netlabel/netlabel_unlabeled.c
net/netlink/af_netlink.c
net/packet/af_packet.c
net/sctp/bind_addr.c
net/sctp/ipv6.c
net/sctp/protocol.c
net/sctp/socket.c
net/socket.c
net/sunrpc/auth.c
net/sunrpc/auth_gss/auth_gss.c
net/sunrpc/sched.c
security/keys/keyring.c
security/keys/proc.c
security/keys/process_keys.c
security/keys/request_key.c
security/selinux/avc.c
security/selinux/netif.c
security/selinux/netlabel.c
security/selinux/netnode.c

if ( some )
  p = RemoveHeadList(&list_head);

/*    
    #define RemoveHeadList(ListHead) \
    (ListHead)->Flink;\
    {RemoveEntryList((ListHead)->Flink)}
*/

GN>if ( some )
GN>  p = RemoveHeadList(&list_head);

GN>/*    
GN>    #define RemoveHeadList(ListHead) \
GN>    (ListHead)->Flink;\
GN>    {RemoveEntryList((ListHead)->Flink)}
GN>*/
GN>

if ( some ) 
{ 
    foo(); 
}

if ( some ) 
    foo();

A>Если надо список лочить, то куда ж вы денетесь-то Если список в > 50% обращений к нему пустой, то оптимизация имеет смысл. Если нет — толку от нее мало, все равно вам хватать spin lock или чего там еще.

A>if ( some ) 
A>{ 
A>    foo(); 
A>}
A>

A>А на чем сейчас ядра пишут? Мне всегда казалось, что как и сто лет назад на голом C Ядрописателям все эти шаблонные оберки-припарки до лампочки.

C++ with its object features appears to be a natural match for the semantics of Microsoft Windows Driver Model (WDM) and Windows Driver Foundation (WDF) drivers.

//
// Calculate the address of the base of the structure given its type, and an
// address of a field within the structure.
//

#define CONTAINING_RECORD(address, type, field) ((type *)( \
                                                  (PCHAR)(address) - \
                                                  (ULONG_PTR)(&((type *)0)->field)))

If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.

This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.

Допустим ты можешь скачать бинарники какой-то свободно распространяемой библиотеки

Если движки для растеризации шрифтов распространяет держатель патента (либо с его разрешения)