當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

std:forward 完美转发

發布時間：2025/3/21 编程问答 32 豆豆

生活随笔收集整理的這篇文章主要介紹了 std:forward 完美转发小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

概述：

?? ?// TEMPLATE CLASS identity
template<class _Ty>
?? ?struct identity
?? ?{?? ?// map _Ty to type unchanged
?? ?typedef _Ty type;

?? ?const _Ty& operator()(const _Ty& _Left) const
?? ??? ?{?? ?// apply identity operator to operand
?? ??? ?return (_Left);
?? ??? ?}
?? ?};

?? ?// TEMPLATE FUNCTION forward
template<class _Ty> inline
?? ?_Ty&& forward(typename identity<_Ty>::type& _Arg)
?? ?{?? ?// forward _Arg, given explicitly specified type parameter
?? ?return ((_Ty&&)_Arg);
?? ?}

?? ??? ? 調用方式： ???? _STD forward<_Ty>(_Val));

簡單來說，identity 用于告訴編譯器，我不要你幫我推導類型了(寫成式子就是 forward(_val)，不帶 <_Ty> 的 )，我自己明確指定類型 ( identity<_Ty>::type)。這樣在傳入參數時，編譯器就不會自己猜想：把 _arg 想成左值了（折疊規則，這個規則是寫這個編譯器的人規定的，我們就不要費力去問為什么要這樣做了，如果你偏要問，那你可以自己定義規則，這樣就變成了你自己的編譯器了）。

引用折疊規則：
X& + & => X&????? (1)
X&& + & => X&?? (2)
X& + && => X&?? (3)
X&& + && => X&& (4)

outer(X&& t)

{

? inner(t)

}

inner(X&&)

如2，意思是把外部右值 X&& t 傳給函數? inner(X&&), 到了 inner函數里， a 就變認為是左值了，即 X&.

給它變成

? inner( _STD forward<_Ty>(t))

那么這時編譯器執行函數 inner前，會對傳給 t 的類型進行推導，而當指明類型為? identity<_Ty>::type, 編譯器放棄了自動推導，認為調用者已經明確指定了類型為 ...type, 當然 forward 返回的類型也要為右值 X&&。你也許會問為什么要為 X&&, 而不為 X&. 這不廢話嗎，舊的編譯器由于推導機制會把右值認為成左值，不會把左值認為是右值，使用新的 forward ，就是為了保持右值的性質不變。

上篇：

轉發問題

在程序員不用寫高度泛化的代碼的時候，C++98/03 的 lvalue， rvalue，引用，還有模板看起來是很完美的。假設你要寫一個完全泛化的函數 outer()，這個函數的目的是將任意數目個任意類型的參數傳遞（也就是“轉發”）給函數 inner()。已有很多不錯的解決方案，比如 factory 函數 make_shared<T>(args) 是把 args 傳給 T 的構造函數，然后返回 shared_ptr<T>。（這樣就把 T 對象和用于對它進行引用計數的代碼存儲到同一塊動態內存中，性能上與侵入式引用計數一樣好）；而像 function<Ret(args)> 這樣的包裝類是把參數傳給其內部存儲的函數對象（functor），等等。在這篇文章里，我們只對 outer() 是如何把參數傳遞給 inner() 這部分感興趣。至于 outer() 的返回類型是怎么決定的是另外的問題（有時候很簡單，如 make_shared<T>(args) 總是返回 shared_prt<T>，），但要在完全搞定這個問題的一般化情況，你就要用到 C++0x的 decltype 特性了）。

如果不帶參數，就不存在這樣的問題，那么帶一個參數情況呢？讓我們嘗試寫個 outer（）：

template <typename T> void outer(T& t) {

??? inner(t);

}

問題來了，如果傳給它的參數是非常量 rvalue，那我們就無法調用 outer()。如果 inner() 接收 const int& 型的參數，那 inner(5) 是可以通過編譯的，但是 outer(5) 就編譯不過了。因為 T 會被推導為 int，而 int& 是不能綁定到常量 5 的。

好吧，讓我們試試這個：

template <typename T> void outer(const T& t) {

??? inner(t);

}

如果 inner（）接收 int& 型參數，那就會違法 const 正確性，編譯都過不了。

現在，你可以重載兩個分別帶 T& 和 const T& 參數的 outer（），這確實管用。當你調用 outer（）時，就像直接調用 inner（）一樣。

可惜的是，這中方法在多參數的情況下就麻煩了（譯注：要寫的重載函數太多了）。你就得為每一個參數像 T1& 和 const T1&, T2& 和 const T2& 等這樣進行重載，要重載的函數數目呈指數級增長。（VC9 SP1 的 tr1：：bind() 就夠讓人感到絕望了，它為 5 個參數這么重載出了 63 個函數。如果不這么蠻干的話，沒有像這里的長篇累述，我們就很難跟使用者解釋為什么不能調用用 1729 這樣的 ravlue 做參數的函數。為了產生出這些重載函數使用了令人作嘔的預處理機制，惡心到你都不想知道它）。

在 C++98/03 中，轉發問題是很嚴重的，而且本質上無解（必須求助于惡心的預處理機制，這會嚴重拖慢編譯速度，還讓代碼變得難以閱讀）。總算， rvalue 優雅地解決了這個問題。

完美轉發：模式

完美轉發讓你能簡單而清晰地只寫一個模板函數就可以轉發所有的參數給任意函數，不管它帶幾個參數，也不管參數類型是什么。而且參數的非常量/常量， lvalue/rvalue 屬性都能得以保留，讓你可以像使用 inner（）一樣使用 outer（），還可以和 move 語意一起用從而獲得額外的好處。（ C++0x 的變長模板技術解決了“任意數目”這部分，我們在這里把 N 看做任意數目）。乍看之下很神奇，實際上很簡單：

C:\Temp>type perfect.cpp

#include <iostream>

#include <ostream>

using namespace std;

template <typename T> struct Identity {

??? typedef T type;

};

template <typename T> T&& Forward(typename Identity<T>::type&& t) {

??? return t;

}

void inner(int&, int&) {

??? cout << "inner(int&, int&)" << endl;

}

void inner(int&, const int&) {

??? cout << "inner(int&, const int&)" << endl;

}

void inner(const int&, int&) {

? ??cout << "inner(const int&, int&)" << endl;

}

void inner(const int&, const int&) {

??? cout << "inner(const int&, const int&)" << endl;

}

template <typename T1, typename T2> void outer(T1&& t1, T2&& t2) {

??? inner(Forward<T1>(t1), Forward<T2>(t2));

}

int main() {

??? int a = 1;

??? const int b = 2;

??? cout << "Directly calling inner()." << endl;

??? inner(a, a);

??? inner(b, b);

??? inner(3, 3);

??? inner(a, b);

??? inner(b, a);

??? inner(a, 3);

??? inner(3, a);

??? inner(b, 3);

??? inner(3, b);

??? cout << endl << "Calling outer()." << endl;

??? outer(a, a);

??? outer(b, b);

??? outer(3, 3);

??? outer(a, b);

??? outer(b, a);

??? outer(a, 3);

??? outer(3, a);

??? outer(b, 3);

??? outer(3, b);

}

C:\Temp>cl /EHsc /nologo /W4 perfect.cpp

perfect.cpp

C:\Temp>perfect

Directly calling inner().

inner(int&, int&)

inner(const int&, const int&)

inner(int&, const int&)

inner(const int&, int&)

inner(int&, const int&)

inner(const int&, int&)

inner(const int&, const int&)

Calling outer().

inner(int&, int&)

inner(const int&, const int&)

inner(int&, const int&)

inner(const int&, int&)

inner(int&, const int&)

inner(const int&, int&)

inner(const int&, const int&)

兩行！完美轉發只用了兩行！夠簡潔吧！

這個例子示范了怎么把 t1 和 t2 從 outer（）透明地轉發給 inner（）； inner（）可以知道它們的非常量/常量， lvalue/ravlue 屬性，就像inner是被直接調用的那樣。

跟 std：：move() 一樣， std::identify 和 std::forward() 都是在 C++<utility> 中定義的（ VC10 會有， VC10 CTP中沒有）。我將演示怎么來實現它們。（再次，我將交替使用 std::identity 和我的 Identity， std::forward() 和我的 Forward()，因為他們的實現是等價的。）

現在，讓我們來揭開“魔術“的神秘面紗，其實它靠的就是模板參數推導和引用折疊(reference collapsing)技術。

rvalue 引用：模板參數推導和引用折疊(reference collapsing)

rvalue 引用與模板以一種特別的方式相互作用。下面是一個示例：

C:\Temp>type collapse.cpp

#include <iostream>

#include <ostream>

#include <string>

using namespace std;

template <typename T> struct Name;

template <> struct Name<string> {