Eric Niebler wrote:
(Some fancy auto_ptr-like move shenanigans are needed to make the lock return-able but not copy-able.)
I think there's a better way to express types that are movable but not copyable, which could work on more compilers. struct lock; lock try_lock(); template<class T, class U> struct enable_move {}; template<class T> struct enable_move<T, T const> { typedef typename T::error_cant_move_from_const type; }; template<class T> struct enable_move<T, T> { typedef int type; }; struct lock { lock(lock const& other) { // move the lock from const_cast<lock&>(other) } lock& operator=(lock const& other) { // move the lock from const_cast<lock&>(other) } operator bool() const { // TODO return true iff we're holding the lock return true; } private: friend lock try_lock(); lock(){} // a try-lock c'tor // make this type non-copyable, non-assignable template<class T> lock(T&, typename enable_move<lock, T>::type = 0); template<class T> typename enable_move<lock, T>::type operator=(T&); }; inline lock try_lock() { // call a special try-lock c'tor on lock return lock(); } int main() { if( lock l = try_lock() ) { } if ( lock const& l = try_lock() ) // doesn't compile on comeau with // the auto_ptr ref thing { } } -- Daniel Wallin