性能翻倍！揭秘編譯器如何偷偷加速你的 C++代碼：RVO/NRVO 詳解
前段時間我在調試一段代碼時，發現了一個有趣的現象：我寫了一個函數，它返回了一個超大的對象（幾G那種），按理說這玩意復制一次得花不少時間，可實際運行起來卻快得出奇。
當時我就納悶了：這不科學?。?/p>
直到我深究了"RVO"和"NRVO"，這才恍然大悟。原來編譯器早就偷偷幫我們做了優化，只是我們不知道而已！
今天，就讓我們一起來扒一扒這些編譯器背后的小動作，看看它們是如何在你不經意間就幫你的代碼提速的。不管你是剛入門的小白，還是已經寫了幾年代碼的老鳥，相信都能從中有所收獲。
一、什么是返回值優化(RVO)？
1. 先來聊聊沒有優化時會發生什么
想象一下這個場景：你寫了一個函數，它需要返回一個大對象，比如說這樣：
class BigObject {
// 假設這個類很大，有一大堆數據
char *data;
// ...其他成員
public:
BigObject() {
cout << "構造函數被調用" << endl;
}
BigObject(const BigObject& other) {
cout << "復制構造函數被調用" << endl;
// 復制數據
}
~BigObject() {
cout << "析構函數被調用" << endl;
}
};
BigObject createBigObject() {
// 直接返回一個臨時對象
return BigObject(); // 返回一個無名臨時對象
}
int main() {
BigObject myObj = createBigObject(); // 調用函數并接收返回值
// 使用myObj...
return 0;
}按照 C++ 的基本規則，這段代碼的執行過程應該是這樣的：
- 在createBigObject()函數內部創建一個臨時的BigObject對象
- 當函數返回時，把這個臨時對象復制一份到main()函數的myObj變量中
- 銷毀函數內的臨時對象
所以按道理說，這里至少會調用一次構造函數和一次復制構造函數，對吧？
但是！如果你實際運行這段代碼并打印出構造和復制構造的調用情況，你很可能會驚訝地發現：復制構造函數根本沒被調用！
這是為什么呢？這就是今天的主角——返回值優化(Return Value Optimization, RVO)在默默發揮作用。
2. RVO是什么鬼？
RVO，全稱 Return Value Optimization，中文叫"返回值優化"，是一種編譯器優化技術。簡單來說，它可以消除函數返回時的對象復制操作。
回到剛才的例子，使用 RVO 后，編譯器會直接在main()函數的myObj變量所在的內存位置上構造對象，而不是先在createBigObject()函數內構造，再復制出來。這樣就完全省去了復制的開銷！
是不是很神奇？明明我們寫的代碼邏輯上需要復制，但編譯器卻偷偷幫我們優化掉了。這種優化在 C++11 標準中被稱為"復制省略"(copy elision)，是少數幾個允許編譯器改變程序可觀察行為的優化之一。
二、NRVO：RVO的近親兄弟
說完了RVO，我們再來看看它的"近親兄弟"——NRVO。
NRVO 全稱是 Named Return Value Optimization，中文可以叫做"具名返回值優化"。這名字聽起來有點繞，但其實很好理解：它就是針對有名字的局部變量的返回值優化。
看下面這個例子：
BigObject createBigObject() {
BigObject result; // 創建一個具名對象
// 對result做一些處理...
return result; // 返回這個具名對象
}這種情況下，我們創建了一個名為result的局部變量，并在最后返回它。這就是 NRVO 的應用場景。
相比之下，我們前面已經看到了RVO的例子，它是針對返回無名臨時對象的優化：
BigObject createBigObject() {
// 直接返回一個臨時對象
return BigObject();
}雖然兩者有細微差別，但目的都是一樣的：避免不必要的對象復制，提高程序性能。
三、深入理解：RVO和NRVO如何實現？
好了，現在我們知道了 RVO 和 NRVO 是什么，但它們是如何實現的呢？編譯器到底在背后做了什么魔法？讓我們揭開謎底！
1. 編譯器的巧妙把戲
傳統情況下，當函數返回一個對象時，會經歷這樣的過程：
- 在函數內創建一個局部對象
- 復制這個對象到返回值位置
- 銷毀函數內的局部對象
但使用 RVO/NRVO 時，編譯器耍了個聰明的把戲：
- 在調用者的棧上直接分配返回值的空間
- 將這個空間的地址偷偷傳給被調用函數
- 被調用函數直接在這個地址上構造對象
就這么簡單！沒有復制，沒有移動，對象直接在它最終應該在的位置上誕生。
我們來看看這在匯編代碼中是什么樣子的，以我們前面的RVO例子為例：
BigObject createBigObject() {
return BigObject(); // 返回一個無名臨時對象
}
int main() {
BigObject myObj = createBigObject();
return 0;
}讓我們來對比一下開啟 RVO 和未開啟 RVO 時的匯編代碼差異，這樣對比會更有說服力。
未開啟RVO優化時（使用 -fno-elide-constructors的編譯選項）：
createBigObject:
; rdi包含返回值的地址
; 在返回地址構造BigObject
call BigObject::BigObject() ; 調用構造函數
ret ; 返回
main:
; 為myObj分配空間
sub rsp, 40000 ; 假設BigObject占用40000字節
; 為臨時返回值分配空間
sub rsp, 40000 ; 再分配一塊空間存儲函數返回值
; 調用createBigObject
lea rdi, [rsp] ; 傳遞臨時返回值的地址
call createBigObject
; 現在需要把臨時返回值復制到myObj
lea rdi, [rsp+40000] ; 目標地址(myObj)
lea rsi, [rsp] ; 源地址(臨時返回值)
call BigObject::BigObject(BigObject const&) ; 調用復制構造函數
; 釋放臨時返回值
lea rdi, [rsp]
call BigObject::~BigObject ; 調用臨時對象的析構函數
add rsp, 40000 ; 釋放臨時返回值的空間
add rsp, 40000 ; 釋放myObj的空間
xor eax, eax ; 返回0
ret開啟RVO優化時（默認就開啟）：
createBigObject:
; rdi中已經包含了目標對象的地址
; 直接在目標地址上構造BigObject
mov QWORD PTR [rdi], 0 ; 初始化部分數據
mov QWORD PTR [rdi+8], 0 ; 初始化更多數據
; ...更多初始化代碼...
; 返回（對象已經構造在調用者提供的內存中）
ret
main:
; 為myObj分配空間
sub rsp, 40000 ; 假設BigObject占用40000字節
; 調用createBigObject，并傳遞myObj的地址作為隱藏參數
lea rdi, [rsp] ; 將myObj的地址加載到rdi寄存器（第一個參數）
call createBigObject
; myObj已經構造好了，清理并返回
add rsp, 40000
xor eax, eax ; 返回0
ret看一眼這兩段匯編代碼，差異顯而易見。未優化的版本明顯更復雜：它要分配兩塊內存空間，而不是一塊；它調用了構造函數，然后又調用復制構造函數和析構函數；它需要進行內存復制，還有更多的棧操作。
相比之下，RVO優化版本簡潔明了：只分配一塊內存空間，只調用一次構造函數，沒有復制，沒有析構，也沒有額外的棧操作。對于大對象來說，這種差異帶來的性能提升是相當可觀的！
2. NRVO與RVO有何不同？
那 NRVO 呢？它與 RVO 在實現上有什么區別？
在 RVO 中，編譯器一看到return BigObject()就知道這是個臨時對象，直接在目標位置構造它很容易。
而 NRVO 要復雜一些。當編譯器看到BigObject obj;時，它不確定這個對象是否只用于返回。只有分析整個函數后，確認 obj 沒有被多次修改或以復雜方式使用，才能將它直接構造在返回位置。
舉個例子：
BigObject createComplex(bool condition) {
BigObject obj1;
BigObject obj2;
// ...
if (condition) {
obj1 = obj2; // obj1被修改了！
return obj1;
}
return obj2;
}這種情況下，編譯器可能無法應用NRVO，因為：
- 可能返回不同的對象（obj1或obj2）
- 對象在返回前被修改了
- 函數邏輯依賴運行時條件
簡單來說：
- RVO：直接明了，容易實現，優化成功率高
- NRVO：需要更全面的代碼分析，實現更復雜
雖然原理有差異，但成功應用后的效果是相同的：對象都直接在最終位置上構造，完全避免了復制。
3. 來看個實際例子
讓我們用實際代碼來驗證一下 RVO 和 NRVO 的效果：
#include <iostream>
#include <chrono>
usingnamespacestd;
usingnamespacestd::chrono;
class BigObject {
private:
int* data; // 指針，而不是數組
public:
BigObject() {
data = newint[1000000]; // 在堆上分配
for (int i = 0; i < 1000000; i++) {
data[i] = i;
}
cout << "構造函數被調用" << endl;
}
BigObject(const BigObject& other) {
data = newint[1000000]; // 在堆上分配
for (int i = 0; i < 1000000; i++) {
data[i] = other.data[i];
}
cout << "復制構造函數被調用" << endl;
}
~BigObject() {
delete[] data; // 記得釋放內存
}
};
// RVO示例
BigObject createWithRVO() {
return BigObject(); // 返回臨時對象
}
// NRVO示例
BigObject createWithNRVO() {
BigObject obj;
return obj; // 返回具名對象
}
int main() {
// 測試RVO
auto start = high_resolution_clock::now();
BigObject obj1 = createWithRVO();
auto end = high_resolution_clock::now();
cout << "RVO耗時: " << duration_cast<microseconds>(end - start).count() << "us" << endl;
// 測試NRVO
start = high_resolution_clock::now();
BigObject obj2 = createWithNRVO();
end = high_resolution_clock::now();
cout << "NRVO耗時: " << duration_cast<microseconds>(end - start).count() << "us" << endl;
return 0;
}運行這段代碼，我們可以得到明顯不同的結果，這取決于編譯器是否啟用了 RVO/NRVO 優化。
- 禁用RVO優化時（使用編譯選項：g++ -fno-elide-constructors -o run test.cpp -std=c++11）：
構造函數被調用
復制構造函數被調用
復制構造函數被調用
RVO耗時: 14428us
構造函數被調用
復制構造函數被調用
復制構造函數被調用
NRVO耗時: 9674us- 啟用RVO優化時（默認選項：g++ -o run test.cpp -std=c++11）：
構造函數被調用
RVO耗時: 4413us
構造函數被調用
NRVO耗時: 4424us看到沒？差別蠻大！
- 禁用優化時，每個函數調用都要復制兩次對象，耗時挺長。
- 啟用優化后，復制構造函數直接消失了！只需構造一次對象，速度整整快了2-3倍多。
即使是在禁用優化時，你可能注意到 NRVO 比 RVO 稍快 —— 這可能只是測試誤差，但確實有趣。不過重點是：開啟優化后，兩者性能基本一致，完全符合我們的理論分析。
這就是 RVO 和 NRVO 的威力！它們不是魔法，而是實實在在的性能提升，特別是當你的函數需要返回大對象時。
四、什么時候會失效？RVO 和 NRVO 的限制條件
前面我們了解了 RVO 和 NRVO 這兩個強大的優化技術，但它們也不是萬能的。什么情況下這些優化會失效呢？讓我們一起來看看幾種常見情況。
1. 多個返回語句指向不同對象
當函數里有多個返回語句，并且返回的是不同的對象時，編譯器就無法確定應該為哪個對象應用優化：
BigObject createObject(bool condition) {
BigObject obj1;
BigObject obj2;
if (condition) {
return obj1; // 返回第一個對象
} else {
return obj2; // 返回第二個對象
}
}在這種情況下，編譯器通常無法應用NRVO，因為它不能確定是obj1還是obj2會被返回。這完全取決于運行時的condition值。
2. 返回的對象是函數參數
如果函數返回的是一個參數，編譯器通常無法應用RVO：
BigObject returnParameter(BigObject param) {
return param; // 返回的是函數參數
}這里的param已經在調用者那里構造好了，函數只是返回了它的一個副本。編譯器無法在調用者的棧上"預先"構造這個對象，因為它已經存在了。
3. 返回的是類成員變量
當函數返回類的成員變量時，這個變量已經作為對象的一部分存在了，編譯器通常也無法應用RVO：
class Container {
BigObject member;
public:
BigObject getMember() {
return member; // 返回的是類成員變量
}
};因為member的生命周期與函數調用無關（它是Container對象的一部分），編譯器無法將它直接構造在返回值位置。
4. 復雜控制流
當函數中有復雜的控制流（如多層嵌套的條件語句、循環、異常處理等）時，編譯器可能難以分析并應用RVO/NRVO：
BigObject complexFunction() {
BigObject obj;
try {
// 一些可能拋出異常的代碼
if (someCondition) {
throw SomeException();
}
} catch (...) {
return obj; // 在異常處理中返回
}
// 更多復雜控制流...
return obj;
}復雜的控制流會使編譯器難以確定返回路徑和返回對象的情況，從而影響優化。
5. 如何確認優化是否生效？
想知道你的代碼是否觸發了 RVO/NRVO 優化？最簡單的方法就是添加打印語句到構造函數和復制構造函數中，然后運行看看：
class Tracer {
public:
Tracer() { cout << "構造函數" << endl; }
Tracer(const Tracer&) { cout << "復制構造函數" << endl; }
~Tracer() { cout << "析構函數" << endl; }
};
Tracer getTracer() {
return Tracer();
}
int main() {
Tracer t = getTracer();
return 0;
}如果只看到"構造函數"和"析構函數"的輸出，沒有看到"復制構造函數"，那么RVO就成功了！
6. 小貼士：如何提高優化成功率？
- 盡量返回臨時對象（RVO 比 NRVO 更容易被應用）
- 一個函數只返回一個對象（避免多個返回語句返回不同對象）
記住這些小技巧，你的代碼就能更好地利用這些強大的優化功能了！
五、C++17：強制的復制省略
前面我們講了這么多 RVO 和 NRVO 的好處，但你知道嗎？在 C++17 之前，這些優化其實只是編譯器的"好心"，并不是語言標準要求必須做的事情！
1. 從"可選"到"必選"
在 C++17 之前，編譯器可以選擇是否應用 RVO 和 NRVO 優化。也就是說，即使你的代碼寫得再完美，滿足了所有優化條件，編譯器也可以說："不，我就是不想優化。"當然，實際上大多數編譯器都會盡可能地進行這些優化，因為它們確實能帶來很大的性能提升。
但從 C++17 開始，對于 RVO 這種情況（即返回臨時對象），標準明確要求 編譯器必須省略復制/移動操作。這就是所謂的"強制的復制省略"（mandatory copy elision）。
2. 這意味著什么？
用大白話說，就是 C++17 把"情分"變成了"本分"。編譯器不再能偷懶，必須為臨時對象的返回做優化。
最有趣的變化是，以下代碼在 C++17 之前可能無法編譯，但在 C++17 中一定能編譯并正常工作：
class NonCopyable {
public:
NonCopyable() = default;
// 禁止復制
NonCopyable(const NonCopyable&) = delete;
NonCopyable& operator=(const NonCopyable&) = delete;
// 禁止移動
NonCopyable(NonCopyable&&) = delete;
NonCopyable& operator=(NonCopyable&&) = delete;
};
NonCopyable createNonCopyable() {
return NonCopyable(); // C++17前可能報錯，C++17一定沒問題
}
int main() {
NonCopyable obj = createNonCopyable(); // 同上
return 0;
}這段代碼看起來很矛盾：我們創建了一個既不能復制也不能移動的類，然后卻試圖返回它的一個臨時對象。按理說，既然不能復制也不能移動，這個對象就不應該能夠從函數返回到調用者那里。
但在 C++17 中，這段代碼是完全合法的！因為標準要求在這種情況下，編譯器必須直接在main函數的obj變量的內存位置上構造這個NonCopyable對象，完全跳過任何復制或移動操作。
3. 為什么這個變化很重要？
- 代碼行為更可預測：無論使用哪個編譯器，優化效果都是一樣的
- 使用不可復制類型更靈活：如上例所示，即使類禁止了復制和移動，也能輕松返回
- 性能保證更強：標準保證臨時對象返回時不會有額外開銷
不過要注意，NRVO（返回具名對象）在 C++17 中仍然是可選的優化，編譯器可以自行決定是否應用。只有RVO（返回臨時對象）是強制的。
所以，如果你希望代碼在所有 C++17 編譯器上都能獲得優化，返回臨時對象會是更安全的選擇：
// 在所有C++17編譯器上都會被優化
BigObject getBigObject() {
return BigObject(); // 返回臨時對象，強制優化
}
// 可能會被優化，取決于編譯器
BigObject getBigObject2() {
BigObject obj;
return obj; // 返回具名對象，優化是可選的
}六、實戰應用：如何充分利用 RVO 和 NRVO
好了，了解了這么多理論知識，現在該談談怎么在日常編碼中實際運用這些技巧了！下面我們就來看看如何寫出能夠充分利用RVO和NRVO的代碼。
1. 盡可能使用返回值，而不是輸出參數
在C++中，有兩種常見的方式向調用者傳遞新創建的對象：通過返回值或通過輸出參數。
// 方式1：使用輸出參數
void createBigObject(BigObject& outObj) {
// 初始化outObj...
outObj.setData(42);
}
// 方式2：使用返回值
BigObject createBigObject() {
BigObject obj;
obj.setData(42);
return obj;
}哪種更好？ 毫無疑問是第二種！
使用返回值不僅代碼更加清晰（表明函數的目的是"創建"和"返回"某物），而且能夠利用 RVO/NRVO 優化性能。而第一種方式無法利用這些優化。
在現代 C++ 中，你完全不需要擔心返回大對象會影響性能。相反，你應該擁抱返回值風格！
2. 在函數末尾直接返回局部變量
看看下面兩種寫法：
// 不好的寫法
BigObject createBigObject() {
BigObject result;
// 初始化result...
BigObject temp = result; // 多余的復制
return temp;
}
// 更好的寫法
BigObject createBigObject() {
BigObject result;
// 初始化result...
return result; // 直接返回，可能觸發NRVO
}第一種寫法中，我們創建了一個多余的temp對象，并做了一次不必要的復制。這不僅增加了代碼的復雜性，還破壞了NRVO優化的條件。
第二種寫法簡單直接，而且更有可能觸發 NRVO 優化。記?。褐苯臃祷啬阆胍祷氐木植孔兞?，不要繞彎子！
3. 小心使用std::move
初學 C++11 的同學可能會有一個常見誤區：認為給所有返回的對象都加上std::move會提高效率。實際上，這通常是一個巨大的錯誤！
// 錯誤示范！會破壞RVO/NRVO
BigObject createBigObject() {
BigObject obj;
// ...
return std::move(obj); // ? 不要這樣做！可能會阻止NRVO！
}
// 正確做法：直接返回局部變量
BigObject createBigObject() {
BigObject obj;
// ...
return obj; // ? 讓編譯器做優化
}為什么std::move反而會降低性能？因為它告訴編譯器："我要移動這個對象"，這就阻止了編譯器直接在目標位置構造對象的優化路徑。記住：在返回局部變量時，不要使用 std::move！
唯一應該使用 std::move的情況是當你確定 RVO/NRVO 無法應用，而你又想避免復制的時候：
BigObject createBigObject(bool condition) {
BigObject obj1;
BigObject obj2;
// 多返回路徑情況下，NRVO可能失效
// 此時使用移動語義作為"備胎"
if (condition) {
return std::move(obj1); // 這里使用move是合理的
} else {
return std::move(obj2); // 這里也是
}
}4. 使用右值引用和移動構造函數作為后備
從 C++11 開始，我們有了移動語義。即使在 RVO/NRVO 無法應用的場景，移動語義也能提供比復制更高效的方案：
class BigObject {
private:
vector<int> data; // 可能很大的數據
public:
// 移動構造函數
BigObject(BigObject&& other) noexcept
: data(std::move(other.data)) { // 只是轉移指針，不復制數據
cout << "移動構造" << endl;
}
// 常規復制構造函數
BigObject(const BigObject& other)
: data(other.data) { // 復制所有數據，可能很慢
cout << "復制構造" << endl;
}
};通過實現移動構造函數，即使在RVO/NRVO失效的情況下，編譯器也會選擇調用移動構造而不是復制構造，這能顯著提升性能。
5. 實戰小貼士總結
- 優先使用返回值風格，而不是輸出參數
- 直接返回局部變量，不要創建臨時副本
- 不要對返回的局部變量使用std::move，除非你確定 RVO/NRVO 無法應用
- 實現移動構造函數作為后備優化
- 閱讀編譯器生成的匯編代碼（如果你想確認優化是否生效）
掌握了這些技巧，你就能寫出既清晰又高效的C++代碼，充分利用編譯器為你提供的這些免費的性能優化！
七、實際測量：驗證優化效果
理論講得再多，不如親自驗證一下。下面是一個更全面的基準測試代碼，你可以用它來測量不同情況下的性能差異：
#include <iostream>
#include <chrono>
#include <vector>
#include <string>
usingnamespace std;
usingnamespace std::chrono;
// 一個足夠大的類，使性能差異明顯
class BigObject {
private:
vector<int> data;
string name;
public:
BigObject(size_t size = 1000000) : data(size) {
for (size_t i = 0; i < size; i++) {
data[i] = static_cast<int>(i);
}
name = "BigObject";
}
BigObject(const BigObject& other) : data(other.data), name(other.name) {
cout << "復制構造: 復制了 " << data.size() << " 個元素" << endl;
}
BigObject(BigObject&& other) noexcept :
data(std::move(other.data)), name(std::move(other.name)) {
cout << "移動構造被調用" << endl;
}
BigObject& operator=(const BigObject& other) {
if (this != &other) {
data = other.data;
name = other.name;
cout << "復制賦值: 復制了 " << data.size() << " 個元素" << endl;
}
return *this;
}
BigObject& operator=(BigObject&& other) noexcept {
if (this != &other) {
data = std::move(other.data);
name = std::move(other.name);
cout << "移動賦值被調用" << endl;
}
return *this;
}
~BigObject() {
// 析構函數
}
size_t getSize() const { return data.size(); }
};
// 使用RVO（返回臨時對象）
BigObject createWithRVO(size_t size) {
return BigObject(size);
}
// 使用NRVO（返回具名對象）
BigObject createWithNRVO(size_t size) {
BigObject obj(size);
return obj;
}
// 故意阻止RVO/NRVO
BigObject createWithDisabledOptimization(size_t size, bool flag) {
BigObject obj1(size);
BigObject obj2(size);
if (flag) {
return obj1;
} else {
return obj2;
}
}
// 使用移動語義
BigObject createWithMove(size_t size, bool flag) {
BigObject obj1(size);
BigObject obj2(size);
if (flag) {
return std::move(obj1);
} else {
return std::move(obj2);
}
}
// 運行基準測試
template<typename Func>
long long runBenchmark(Func func, int iterations) {
auto start = high_resolution_clock::now();
for (int i = 0; i < iterations; i++) {
BigObject obj = func();
// 做一些操作以防止編譯器過度優化
if (obj.getSize() < 0) cout << "不可能發生" << endl;
}
auto end = high_resolution_clock::now();
return duration_cast<milliseconds>(end - start).count();
}
int main() {
constint iterations = 10;
constsize_t objSize = 1000000;
cout << "測試RVO優化..." << endl;
auto rvoTime = runBenchmark([objSize]() {
return createWithRVO(objSize);
}, iterations);
cout << "\n測試NRVO優化..." << endl;
auto nrvoTime = runBenchmark([objSize]() {
return createWithNRVO(objSize);
}, iterations);
cout << "\n測試無優化情況..." << endl;
auto noOptTime = runBenchmark([objSize]() {
return createWithDisabledOptimization(objSize, rand() % 2);
}, iterations);
cout << "\n測試移動語義..." << endl;
auto moveTime = runBenchmark([objSize]() {
return createWithMove(objSize, rand() % 2);
}, iterations);
cout << "\n性能比較:" << endl;
cout << "RVO: " << rvoTime << "ms" << endl;
cout << "NRVO: " << nrvoTime << "ms" << endl;
cout << "無優化: " << noOptTime << "ms" << endl;
cout << "移動語義: " << moveTime << "ms" << endl;
return0;
}在 Visual Studio 2022 上的測試結果:
測試RVO優化...
測試NRVO優化...
測試無優化情況...
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
測試移動語義...
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
移動構造被調用
性能比較:
RVO: 127ms
NRVO: 118ms
無優化: 241ms
移動語義: 243ms從結果可以看出：
- RVO 和 NRVO 的性能幾乎相同，都非常優秀
- 有趣的是，"無優化情況"和"顯式使用移動語義"的性能也幾乎相同
- 最令人驚訝的是，即使在"無優化情況"下，也調用了移動構造函數，而不是復制構造函數！
1. 編譯器和平臺的影響
不過，值得注意的是，測試結果會受到編譯器、編譯選項和平臺的影響。我是在Visual Studio 2022上進行的測試，發現了一些有趣的現象：
關于移動構造函數的重要發現：
(1) 如果注釋掉BigObject類的移動構造函數，測試結果會有顯著變化：
- "無優化情況"和"移動語義"測試都會調用復制構造函數
- 兩者的性能幾乎完全相同
(2) 反之，如果定義了移動構造函數：
- 兩種情況都會調用移動構造函數
- 性能同樣會非常接近
這個現象解釋了為什么在某些測試環境中，"無優化"和"移動語義"的性能差異不明顯。它說明：
- C++編譯器非常智能：即使在無法應用RVO/NRVO的情況下，如果有移動構造函數可用，現代編譯器會自動選擇移動而非復制
- 添加std::move并不總是必要的：在多返回路徑的情況下，即使不顯式使用std::move，編譯器也可能自動應用移動語義
- 但定義移動構造函數很重要：要讓編譯器能夠選擇移動而不是復制，必須定義移動構造函數
這個測試提醒我們：在進行性能優化時，務必在自己的實際環境中測試，因為不同編譯器和不同編譯選項可能導致不同的優化結果。
這也進一步強調了 C++ 標準庫中"Rule of Five"（五法則）的重要性：如果你定義了任何一個復制構造、復制賦值、移動構造、移動賦值或析構函數，通常應該考慮定義所有五個函數，以確保類的行為一致且性能最優。
八、總結與最佳實踐
講了這么多，是時候把重點內容簡單總結一下了！
1. RVO與NRVO：不再是"大對象別返回"
以前我們常被告誡："C++返回大對象很慢，盡量用指針或引用傳遞"。現在看來，這個說法已經過時啦！
有了RVO和NRVO這兩個強大的優化技術，返回對象不再是性能瓶頸：
- RVO處理臨時對象返回：return BigObject();
- NRVO處理局部變量返回：BigObject obj; return obj;
- C++17讓RVO成為必選項：編譯器必須優化臨時對象返回
- 移動語義是不錯的備胎：當RVO/NRVO失效時的保底方案
最佳編碼實踐包括：直接返回對象而非用輸出參數、直接返回局部變量不做額外復制、不對返回局部變量使用std::move、實現移動構造函數作為后備、使用現代編譯器并開啟優化等。
2. 別被"過早優化"困住
有句名言："過早優化是萬惡之源"。但利用 RVO/NRVO 并非過早優化 — 這些寫法本身就是現代C++的自然表達，代碼更清晰，還能獲得更好性能，何樂而不為？
九、結語：不只是一個優化技巧
RVO 和 NRVO 代表了 C++ 的一個重要理念：零開銷抽象。通過它們，我們可以寫出既清晰又高效的代碼。這正是C++的魅力所在！
希望這篇文章能幫你更好理解和利用這兩個強大的優化技術。C++的優化技巧還有很多，后續我會繼續分享更多實用的 C++ 性能優化知識。
