性能翻倍！揭秘編譯器如何偷偷加速你的 C++代碼：RVO/NRVO 詳解

作者：跟著小康學編程 2025-03-18 08:40:00

開發

你有沒有好奇過，為什么有時候 C++ 代碼明明應該很慢，卻跑得飛快？今天咱們就一起來扒一扒編譯器背后的那些小動作！

前段時間我在調試一段代碼時，發現了一個有趣的現象：我寫了一個函數，它返回了一個超大的對象（幾G那種），按理說這玩意復制一次得花不少時間，可實際運行起來卻快得出奇。

當時我就納悶了：這不科學啊！

直到我深究了"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++ 性能優化知識。

責任編輯：趙寧寧來源：跟著小康學編程

C++代碼編譯器