Intro
Rvalue-References 是 C++0x 規範的新 language feature, 也是繼 Templates 後, IMO, C++ 語言最重要的 language feature. 其目的是為了支持 Move Semantics — 將 resource 從一個 instance 轉移到另一個 instance.
Rvalue — 這個聽起來饒舌的新名詞 — 說穿了其實就是 un-named instance (i.e. temporary), 反之, 有名字的 (named) 則為 lvalue. 而 const/volatile 與否則是額外的修飾. 也就是說, 一個 rvalue reference 其實就是 reference to a temporary.
The Scenario
以一個簡單的 string class 為例:
// listing-1
class String
{
public:
String(const String& other)
: data_(new char[other.length_]),
length_(other.length_)
{
copy(
other.data_,
other.data_ + other.length_,
data_);
}
// Details omitted…
private:
char* data_;
size_t length_;
};
這個例子可說是 C++ RAII 的典型範例. String class 的 instance 在 copy-construct 的時候, 會先 allocate 一塊 memory, 然後將被複製的對象的內容 copy 過來. 雖然我們可以很明顯的看出複製 String instance 的 cost, 但大多時候這個 cost 並不會造成 C++ programmer 的困擾. 需要複製的時候, 該付出的 cost 本來就是省不掉的, 而絕大多數 C++ programmer 早已知道傳遞 function call parameter 的時候可以用 call-by-reference 以避開不必要的複製:
// listing-2
int compute(const String& arg)
{
// Evaluate `arg’ and do some computation…
return hash;
}
String produce()
{
// Produce then return a String instance…
}
// listing-3
void client()
{
String arg(produce());
int hash = compute(arg);
}
讓我們把狀況稍微搞複雜一點, 如果餵給 compute() 的參數不是一個 lvalue, 而是一個如 return value 的 rvalue 呢:
// listing-4
void client()
{
int hash = compute(produce());
}
這也沒問題, 一個 temporary 的生命周期跟指向它的 const reference 一樣長, 與下面的狀況是相同的:
// listing-5
void client()
{
int hash = compute(”blah”);
}
The Problem
目前為止, 即便跨了數個 stack frame, 在我們的 code stack 上只有一份 String instance, 沒有發生複製, 一切都很理想. 現在假設 compute() 這個 function 需要對客戶端給的 parameter 作 local 的修改以利運算, 譬如把 double quote (") remove 掉:
// listing-6
int compute2(const String& arg)
{
String var(arg);
var.Remove(’\”‘);
// Evaluate `var’ and do some computation…
return hash;
}
我們甚至可以針對像是 listing-3 — 以 lvalue 為參數的客戶端進行 overload:
// listing-7
int compute2(String& arg)
{
arg.Remove(’\”‘);
// Evaluate `arg’ and do some computation…
return hash;
}
然後再改寫 listing-6 的版本, 以利 code reuse:
// listing-8
int compute2(const String& arg)
{
String var(arg);
return compute2(var);
}
先不論 listing-7 的 compute2() 對客戶端參數做修改的恰當與否, compute2() 的確在特定狀況下避開了複製. Note: listing-7 與 listing-8 的 compute2() 為同時存在的兩個 overload. 但這方法好嗎? 一點也不.
當參數 為 rvalue 時 (如 listing-4 and listing-5), 客戶端絕對是沒有可能繼續參考該 instance. 反之, 在參數為 lvalue 時 (如 listing-3), 客戶端很可能打算接下來繼續使用該 instance, 但卻會被 compute2() 給修改了. 這樣的 overload 對用戶端可能需要繼續使用的 instance 進行 mutable 操作, 卻放過完全可以安全重複使用的狀況.
One Option
若要能正確接收能放心重複使用的參數, 以現行 C++ Standard, 唯一的方法是在 String class 內 implement 類似 auto_ptr/auto_ptr_ref 的機制.
這方法不但非語言標準, 除了要針對每個支持這語意的 user-defined class 多寫不少 code, 也無法在 compile 階段阻止使用者做出錯誤的操作, 如:
// listing-9
template <class T>
void leak(auto_ptr<T> foo)
{
auto_ptr_ref<T> leaked(foo);
}
Note: listing-9 會把 foo 管理的指標 leak 掉.
更糟糕的是, 光是類似 auto_ptr/auto_ptr_ref 的機制是不夠的, 這樣的機制只能達成 always-move 的功能, 無法放過 lvalue 的參數. 要達到全面的支持 — 連同放過 lvalue — 還需要寫更多 code…
The Solution — Rvalue References
C++0x 的 Rvalue References, 這個新的 language feature 就是為了解決這難題而誕生的.
要完整支持 Rvalue References, 首先我們得替 String class 加一個新的建構子 — Move-Constructor:
// listing-11
class String
{
public:
String(const String& other);
String(String&& other)
: data_(other.data_),
length_(other.length_)
{
other.data_ = nullptr;
other.length_ = 0;
}
// Details omitted…
};
為了避免無意間下觸發 move 機制, 在 C++0x 的規範中 lvalue 被自動轉為 rvalue reference 的優先順序較低. 在 lvalue 與 rvalue 都可行的狀況下, 使用者必須顯性轉換 (explicit cast). 這時候 String 的 client code 可以以 resource 轉移的方式建構新的 String instance:
// listing-12
void bar()
{
String src(”blah”);
// This triggers String’s move-ctor.
String dst(static_cast<String&&>(src));
}
為了給使用者容易表達的語法以及清楚的語意, C++0x 定義了叫 move() 的 helper function template:
// listing-13
template <class T>
typename remove_reference<T>::type&&
move(T&& x)
{
return x;
}
特別注意, as a special case, 在 template funciton 內, 如上例, 如果 caller 給的參數為 lvalue, 則 T 為 reference type. 若參數為 rvalue, 則 T 為 plain type. 於是 move() 的功能就只是把參數 x 轉為一個 rvalue reference, 不論 x 原來究竟是 lvalue/rvalue 還是本來就是 rvalue reference. 讓使用者可以以明白的顯性方式使用 move semantics, bar() 的 code 就可以改成:
// listing-14
void bar2()
{
String src(”blah”);
// This also triggers String’s move-ctor.
String dst(move(src));
}
到了這裡, 我們應該已經知道 — 在使用有 Rvalue References 支持的 compiler 時 — 該如何正確地寫出理想的 compute2() 的 overload, 就叫 compute3() 吧:
// listing-15
int compute3(String&& arg)
{
arg.Remove(’\”‘);
// Evaluate `arg’ and do some computation…
return hash;
}
// listing-16
int compute3(const String& arg)
{
String var(arg);
return compute3(move(var));
}
在 client code 不需要繼續使用餵給 compute3() 的參數時可以這樣寫:
// listing-17
void client3a()
{
// Call to compute3() as of listing-15.
int hash = compute3(move(produce()));
}
或是畫蛇添足一下:
// listing-18
void client3b()
{
String arg(move(produce()));
// Call to compute3() as of listing-15.
int hash = compute3(move(arg));
// Note that `arg’ is now in an user-defined empty state.
// Similar to a released auto_ptr.
}
若還需要繼續參考該參數時:
// listing-19
void client3c()
{
String arg(move(produce()));
// Call to compute3() as of listing-16.
int hash = compute3(arg);
// Continue doing more computation with possible references to `arg’.
}
References
]]>
from Larry Osterman’s WebLog.