Good question. I attempted writing a similar sort of proxy class recently but never achieved a good solution. The best I found was calling a member function on every use where the proxy was required to be an r-value: ORef<T> move() { return ORef<T>( this->release() ); } This changes the semantics of declaring something an … Read more
A non-const reference cannot point to a literal. You cannot bind a literal to a reference to non-const (because modifying the value of a literal is not an operation that makes sense) and only l-values can be bound to references to non-const. You can however bind a literal to a reference to const. The “const” … Read more
For your particular case, the second overload is useless. With the original code, which has just one overload for Load, this function is called for lvalues and rvalues. With the new code, the first overload is called for lvalues and the second is called for rvalues. However, the second overload calls the first one. At … Read more
It’s my fault. (half-kidding, half-not). When I first showed example implementations of move assignment operators, I just used swap. Then some smart guy (I can’t remember who) pointed out to me that the side effects of destructing the lhs prior to the assignment might be important (such as the unlock() in your example). So I … Read more
There are a few occasions when it is appropriate, but they are relatively rare. The case comes up in one example when you want to allow the client to move from a data member. For example: template <class Iter> class move_iterator { private: Iter i_; public: … value_type&& operator*() const {return std::move(*i_);} … };
This is not how std::make_pair is intended to be used; you are not supposed to explicitly specify the template arguments. The C++11 std::make_pair takes two arguments, of type T&& and U&&, where T and U are template type parameters. Effectively, it looks like this (ignoring the return type): template <typename T, typename U> [return type] … Read more
They are occasionally useful. The draft C++0x itself uses them in a few places, for example: template <class T> void ref(const T&&) = delete; template <class T> void cref(const T&&) = delete; The above two overloads ensure that the other ref(T&) and cref(const T&) functions do not bind to rvalues (which would otherwise be possible). … Read more
It is correct that std::move(x) is just a cast to rvalue – more specifically to an xvalue, as opposed to a prvalue. And it is also true that having a cast named move sometimes confuses people. However the intent of this naming is not to confuse, but rather to make your code more readable. The … Read more
You would do: template <typename …Params> void f(Params&&… params) { y(std::forward<Params>(params)…); } The … pretty much says “take what’s on the left, and for each template parameter, unpack it accordingly.”
You have to understand the forwarding problem. You can read the entire problem in detail, but I’ll summarize. Basically, given the expression E(a, b, … , c), we want the expression f(a, b, … , c) to be equivalent. In C++03, this is impossible. There are many attempts, but they all fail in some regard. … Read more