VC10中的C++0x特性 part 2（2）:右值引用

核心提示： 这是怎么回事呢？记住：在C++98/03中，具名 lvalue 引用是左值(给定语句 int& r = *p; r 是 lvalue)，VC10中的C++0x特性 part 2（2）:右值引用(3)，不具名 lvalue 引用还是左值(给定语句 vector<int> v(10

这是怎么回事呢？记住：在C++98/03中，具名 lvalue 引用是左值(给定语句 int& r = *p; r 是 lvalue)，不具名 lvalue 引用还是左值(给定语句 vector<int> v(10, 1729)， v[0] 返回 int&， 你可以对这个不具名 lvalue 引用取址)。但是 rvalue 引用就不一样了：

 具名 lvalue 引用是 lvalue。

 不具名 rvalue 引用是 rvalue。

一个具名 rvalue 引用是一个 lvalue 是因为可以对它施加多重操作，重复使用。相反，如果它是一个 ravlue 的话，那么对它施加的第一个操作能够“窃取”它，而后续操作就没机会了。这里的“窃取”是说不会被察觉到，所以这是行不通的。另一方面，不具名 rvalue 引用不能被重复使用，所以它仍保持右值(rvalueness)语意。

如果你真的打算用 move 赋值函数来实现 move 构造函数，你需要从 lvalue move，就像是从 rvalue move 一样。C++0x <utility> 中的 std::move() 具备这样的能力，VC10将会有这个（实际上，开发版中已经有了），但VC10 TCP版还没有，所以我会教你从头做起：

C:Temp>type unified_right.cpp
#include <stddef.h>
#include <iostream>
#include <ostream>
using namespace std;

template <typename T> struct RemoveReference {
　　　　 typedef T type;
};

template <typename T> struct RemoveReference<T&> {
　　　　 typedef T type;
};

template <typename T> struct RemoveReference<T&&> {
　　　　 typedef T type;
};

template <typename T> typename RemoveReference<T>::type&& Move(T&& t) {
　　　 return t;
}

class remote_integer {
public:
　　　 remote_integer() {
　　　　　　　 cout << "Default constructor." << endl;

　　　　　　　 m_p = NULL;
　　　 }

　　　 explicit remote_integer(const int n) {
　　　　　　　 cout << "Unary constructor." << endl;

　　　　　　　 m_p = new int(n);
　　　 }

　　　 remote_integer(const remote_integer& other) {
　　　　　　　 cout << "Copy constructor." << endl;

　　　　　　　 m_p = NULL;
　　　　　　　 *this = other;
　　　 }

#ifdef MOVABLE
　　　 remote_integer(remote_integer&& other) {
　　　　　　　 cout << "MOVE CONSTRUCTOR." << endl;

　　　　　　　 m_p = NULL;
　　　　　　　 *this = Move(other); // RIGHT
　　　 }
#endif // #ifdef MOVABLE

　　　 remote_integer& operator=(const remote_integer& other) {
　　　　　　　 cout << "Copy assignment operator." << endl;

　　　　　　　 if (this != &other) {
　　　　　　　　　　　 delete m_p;

　　　　　　　　　　　 if (other.m_p) {
　　　　　　　　　　　　　　　 m_p = new int(*other.m_p);
　　　　　　　　　　　 } else {
　　　　　　　　　　　　　　　 m_p = NULL;
　　　　　　　　　　　 }
　　　　　　　 }

　　　　　　　 return *this;
　　　 }

#ifdef MOVABLE
　　　 remote_integer& operator=(remote_integer&& other) {
　　　　　　　 cout << "MOVE ASSIGNMENT OPERATOR." << endl;

　　　　　　　 if (this != &other) {
　　　　　　　　　　　 delete m_p;

　　　　　　　　　　　 m_p = other.m_p;
　　　　　　　　　　　 other.m_p = NULL;
　　　　　　 　}

　　　　　　　 return *this;
　　　 }
#endif // #ifdef MOVABLE

　　　 ~remote_integer() {
　　　　　　　 cout << "Destructor." << endl;

　　　　　　　 delete m_p;
　　　 }

　　　 int get() const {
　　　　　　　 return m_p ? *m_p : 0;
　　　 }