在我們開始講解std::move之前，先來介紹一個概念：引用摺疊。這個概念僅用於 typedef 和 模板型別引數 中。

在模板世界中，T&& 稱為Universal Reference，即通用引用。這與普通函式中形參的&&是不同的，希望不要弄混了。

對於模板函式template <typename T> void func(T&& t)，對於左值實參，T&& t 推匯出的T為string&；對於右值實參，T&& t 推匯出的T為string。

對於左值引用X&，具有傳染性，即X& &、X& &&和X&& &都摺疊成型別X&；

對於右值引用X&&，只有X&& &&才摺疊成X&&。

下面我們來實戰一下：

template <typename T>
void func(T&& val) {
	T t = val;
	t++;
	if(val == t) { //... }
}

如果傳入的是一個右值42，此時T的型別為int，此時if判斷永遠為false；如果傳入的是一個左值整型變數，則T為int&，此時，if判斷永遠是true。

T&&通常用於兩種情況：模板轉發或模板過載。對於模板過載，通常使用以下方式進行過載：

template <typename T> void func(T&&);
template <typename T> void func(const T&);

好，下面進入正題。

一、先來看一下C++標準原始碼中是怎麼實現std::move模板函式的。

//<bits/move.h> <utility>
/**
*  @brief  Convert a value to an rvalue.
*  @param  __t  A thing of arbitrary type.
*  @return The parameter cast to an rvalue-reference to allow moving it.
*/
template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
 

其中，用到了std::remove_reference<_Tp>，這是定義在<type_traits>標頭檔案中的。

// <type_traits>
  /// remove_reference
template<typename _Tp>
	struct remove_reference
		{ typedef _Tp   type; };

template<typename _Tp>
	struct remove_reference<_Tp&>
		{ typedef _Tp   type; };

template<typename _Tp>
	struct remove_reference<_Tp&&>
		{ typedef _Tp   type; };

根據模板匹配，最終reremove_reference返回的都是脫去引用後的普通型別。所以，std::remove_reference<_Tp>::type&& 一定是該型別的右值引用。雖然不能隱式將一個左值轉換為右值引用，但是我們可以顯式地使用static_cast將一個左值轉換為右值引用。

C++標準規定，對於具名的右值引用，是一個左值；但是，對於一個無名的右值引用，是一個右值。std::move返回的正是一個無名的右值引用，所以是一個右值。這就是強制把一個左值變為右值引用的函式，當然，該函式也可以作用於右值，返回結果仍然是該右值的引用。

此時，肯定有人會說，既然這樣，那為什麼我要用std::move函式，我直接使用static_cast強轉就OK了。是的，雖然我們可以直接使用static_cast進行右值引用強轉，但是，使用標準庫move函式是容易得多的方式。而且，統一使用std::move使得我們在程式中查詢潛在的截斷左值的程式碼變得很容易。

同時，move的名字衝突要比其他標準庫函式的衝突頻繁得多。而且，因為move執行的是非常特殊的型別操作，所以程式專門修改函式原有行為的概率非常小。對move，其實還有forward來說，衝突很多，但大多數是無意的，這一特點解釋了為什麼會使用帶限定語的完整版本的原因。通過書寫std::move而非move，我們就能明確地知道想要使用的是函式的標準庫版本。

二、再來看一下C++標準原始碼中是怎麼實現std::forward模板函式的。

//<bits/move.h>  <utility>  
  // forward (as per N3143)
  /**
   *  @brief  Forward an lvalue.
   *  @return The parameter cast to the specified type.
   *
   *  This function is used to implement "perfect forwarding".
   */
  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }

  /**
   *  @brief  Forward an rvalue.
   *  @return The parameter cast to the specified type.
   *
   *  This function is used to implement "perfect forwarding".
   */
  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
		    " substituting _Tp is an lvalue reference type");
      return static_cast<_Tp&&>(__t);
    }

與move不同的是，forward必須通過顯式模板來呼叫，forward返回該顯式實參型別的右值引用。即：std::forward<T>的返回型別是T&&。顯然，如果T是int&，則T&&仍是int&。如果T是int&&，則T&&仍是int&&。從而forward會保持實參型別的所有細節，包括const，因為對於引用來說，const都是底層的，都會予以保留。