[[382320]]

本文轉載自微信公眾號「程序喵大人」，作者程序喵大人。轉載本文請聯系程序喵大人公眾號。

本專題將分析C++各種代碼操作的效率，包括不同類型變量的存儲效率，使用智能指針、循環、函數參數、虛函數、數組等的效率，以及如何做針對性優化，或選擇更有效的替代方案。

詳細目錄看下圖：

變量存儲區域：

在C++中，變量存儲在哪類內存，取決于開發者聲明它們的方式。如果數據不連續，分成無數段分散在內存中，會降低數據的Cache命中率。因此，理解變量如何存儲非常重要。

棧空間

棧空間，通常用于存儲局部變量、函數參數、函數返回地址、函數返回前需要恢復的寄存器等。每次調用函數時，系統都會分配一段棧空間，用于存儲這些東西，函數返回時，這段棧空間會被回收，下次調用函數時，程序還可以重用這段棧空間。

一般來說，程序每個線程有固定大小的棧空間，使用多少，回收多少，只是偏移量偏移多少的問題。棧空間特別高效是因為同一段內存空間可以被反復使用，內存很容易就加載到Cache中，Cache命中率更高。

我們可以多利用棧空間。所有的變量，最好都在使用它們的函數中聲明。有些情況下可以在大括號{ }內聲明變量，盡可能縮小變量的作用域。

全局或靜態空間

全局變量，任何函數都可以訪問，存儲在內存的靜態空間中。static關鍵字聲明的變量、浮點常量、字符串常量、虛函數表等，都存儲在靜態空間中。

靜態空間的優點是，可以在程序啟動前就將其初始化為所需的值。缺點是，即使變量只使用一次，或者只在程序的一小部分中使用，它的內存，也會在程序整個運行過程中被占用，會降低Cache的效率。

盡量不要將變量聲明為全局變量，一個變量如果被多個函數使用，可以考慮將其作為參數，但是參數傳遞是有開銷的，如果我們想避免這類開銷，難道就要聲明為全局變量了嗎?其實我們也可將變量存儲在類對象中，多個函數都訪問類對象中的變量成員。

某些情況下，可以考慮static和const共用，例如聲明一個靜態常量查詢表：

float SomeFunction(int x) { 
static const float list[] = {1.1, 2.2, 3.4, 4.4, 5.5}; 
    return list[x]; 
} 

這種方式的好處是，不需要在每次調用函數時對列表進行初始化。static聲明意味著在第一次調用初始化后，后續就不再需要初始化，但這樣效率較低，因為需要額外檢查它是第一次調用，還是已經被調用過。加入const聲明，可以告訴編譯器，不需要對是否是第一次調用來進行檢查。所以最好加上static和const聲明，以便讓編譯器更好的優化。

字符串常量和浮點數常量，也經常保存在靜態空間中，例如：

a = b * 3.5; 
c = d + 3.5; 

這里，常數3.5將存儲在靜態空間中，大多數編譯器會識別出這兩個常量是相同的，因此只需要存儲一份常量。整個程序中所有相同的常量將被連接在一起，優化程序中常量的占用空間。

寄存器存儲

寄存器是CPU中的一小塊內存，用作臨時存儲。訪問寄存器中的變量速度非常快，但是寄存器數量有限，存儲的變量也有限。編譯器優化時，會自動選擇函數中的最常用變量，存到寄存器中。程序中的局部變量就很適合于存儲在寄存器中。

寄存器數量有限，32位X86系統中，大約有6個整數寄存器用于通用目的，64位系統中有14個。而浮點變量使用不同的寄存器，32位系統中大約有8個可用的浮點寄存器，64位系統中有16個，當在64位系統中啟用更高級的指令集時，可能會有更多可用的浮點寄存器。

volatile

這里需要特別關注下volatile關鍵字，該關鍵字表示其修飾的變量可以被另一個線程更改，防止編譯器做一些過度優化。例如：

volatile int seconds; 
 
void DelayFiveSeconds() { 
    seconds = 0; 
while (seconds < 5) { 
// do nothing while seconds count to 5 
    } 
} 

在本例中，DelayFiveSeconds()將一直等待，直到另一個線程將seconds增加到5。

如果seconds沒被聲明為volatile，那么編譯器可能會進行過度優化，將假定在while循環中seconds保持為0，循環內的任何內容都不能更改該值。循環將是while(0 < 5){}，這將是個死循環。

關鍵字volatile的作用是，確保變量永遠存儲在內存中，而不是在寄存器中，并阻止對變量的所有優化。

注意volatile不保證原子性，它不會阻止兩個線程同時嘗試寫操作。其他線程增加seconds的同時，試圖將seconds設置為0，這樣可能會失敗。更安全的做法是，一個線程只讀取seconds，并等待該值更改。

thread-local存儲

C++11中可以使用thread_local關鍵字來聲明線程本地變量，C++11前也有別的方式聲明，被修飾的變量對于每個線程都有一份拷貝，保證了線程安全。thread-local存儲效率較低，因為它是通過全局指針訪問。我們應該盡量避免線程本地存儲，可以更多將變量存儲在線程自己的棧中，即在線程自己的函數中聲明變量。

堆內存

堆內存主要通過操作符new和delete動態分配，或者使用函數malloc和free。如果以隨機的順序分配和釋放不同大小的內存，很容易產生內存碎片，分散在堆內存的不同地方，而且頻繁分配內存，開銷也較大。盡量避免動態分配內存吧，或者用JeMalloc替換一波?或內存池?

整數變量和運算

整型大小

整數中，不同類型可能會有不同的大小，下圖總結了不同整型的大小和最大最小值：

在不同的平臺，聲明特定大小整數的方法不同，我們可以使用標準頭文件stdint.h，聲明特定大小的整型，該方法還可以跨平臺，可移植。

大多數情況下，整數運算非常快，但是，如果整數大于可用寄存器大小，效率就會低一些。例如，在32位系統中，使用64位整數效率低一些，特別是用于乘法或除法時。

如果聲明了int類型，但是沒有指定具體大小，編譯器將始終選擇最有效的整數大小。較小大小的整數如char、short int等，效率可能稍微低一些，在很多情況下，編譯器在進行計算時，會將這些類型轉換為默認大小的整數，然后只使用結果中的低8位或者低16位。在64位系統中，只要我們不做除法，使用32位整數和64位整數的效率其實沒多大差別。

整數運算時，我們需要考慮中間計算的結果，看是否會導致溢出。例如表達式a=b+c+d，即使b、c、d都低于整數最大值，但是可能b+c就會導致整數溢出，我們需要時刻注意。

有符號整數和無符號整數

多數情況下，使用有符號整數和無符號整數，在速度上沒有區別，但有一些特殊情況：

常量除法，當除以常量時，無符號整數比有符號整數效率更高，模運算類似。

對于大多數指令集，使用有符號整數到浮點數的轉換，要比使用無符號整數轉換更快。

有符號和無符號整數的溢出行為不同：無符號整數的溢出產生一個低正結果，有符號整數的溢出是官方未定義的。有符號整數，正常的行為是將正溢出轉換為負值，但是編譯器可能做一些優化，它會假設不會發生溢出。

有符號整數和無符號整數之間的轉換，沒有任何開銷。這只不過是對同一符號位的不同解釋而已。負整數在轉換為無符號時，將被解釋為一個非常大的正數。

int a, b; 
double c; 
b = (unsigned int)a / 10; // 轉換成無符號整數做除法更快 
c = a * 2.5; // 有符號整數隱式轉換為double型 

在上例中，將a轉換為unsigned，可以使除法更快。當然，只有當a絕對不會是負數的時候，才可以這么轉換。最后一行，在與常數2.5相乘之前，會隱式地將a轉換為double，因為后者是double，這里a作為有符號整數去轉換，效率更高。

注意，在進行比較操作時，例如<操作，不要混用有符號整數和無符號整數。有符號整數和無符號整數的比較，可能會產生意想不到的結果。

整數運算

整數運算通常非常快。簡單的整數運算，如加法、減法、比較、位運算等，在大多數微處理器上只需要一個時鐘周期。乘法和除法需要更長的時間。整數乘法在奔騰4CPU上需要11個時鐘周期，大多數情況乘法都需要3 - 4個時鐘周期，整數除法需要40 - 80個時鐘周期，具體取決于CPU。

自增和自減運算

++i和i++速度一樣快，當僅用于遞增變量時，使用++i和i++沒有任何區別，效果完全相同，例如：

for(i=0;i

浮點數及其運算

現代x86家族的CPU，有兩種不同類型的浮點寄存器，對應不同類型的浮點指令，每種類型都有優缺點。

x87寄存器

x87寄存器是浮點運算的傳統方法，這些寄存器都有長雙精度，多個寄存器組成了一組寄存器棧，使用寄存器棧的優點有：

所有的計算都是用雙精度完成的不同精度之間的轉換不需要額外的時間。

對于數學函數，如對數函數和三角函數，有一些內置的指令。

代碼很緊湊，在代碼緩存中占用的空間很小。

寄存器棧也有缺點：

由于寄存器棧的組織方式，編譯器很難創建寄存器變量。

浮點數比較速度很慢，除非啟用更高的指令集。

當使用雙精度時，除法、平方根和數學函數，需要更多的時間來計算。

向量寄存器

也叫矢量寄存器，有XMM、YMM或ZMM等寄存器，是進行浮點運算的一種較新的方法，浮點運算以單精度或雙精度完成，中間結果的計算精度始終與操作數相同，使用向量寄存器的優點有：

• 制作浮點寄存器變量很容易。
• 向量操作可用于對向量寄存器中的多個變量進行并行計算。

它也有缺點：

• 不支持長雙精度。
• 混合不同精度的表達式計算，需要精度轉換指令，這可能非常耗時。
• 數學函數必須使用函數庫，但這通常也比內置的硬件函數快。

在幾乎所有具有浮點運算能力的系統中，都可以使用x87浮點寄存器，而XMM、YMM和ZMM寄存器分別需要SSE、AVX和AVX512指令集。

現代編譯器，更多情況下會使用向量寄存器，來進行浮點運算。很少有編譯器可以混合兩種不同類型的浮點運算，不能為每次運算選擇最優類型。大多數情況下，當沒有使用向量運算時，單精度浮點數運算和雙精度浮點數運算速度大體相同，無論精度如何，加法、減法、乘法等運算的速度都是相同的。但如果開啟向量運算，使用XMM等向量寄存器時，單精度除法、平方根和數學函數的計算速度要比雙精度快。

如果真的對精度有高要求，可以使用雙精度浮點數，不需要太擔心速度。但如果我們可以利用好向量運算，或者有個大的浮點數數組，想要充分利用Cache，那可以考慮使用單精度浮點數。

浮點加法需要3 - 6個時鐘周期，乘法操作需要4 - 8個時鐘周期，除法需要14 - 45個時鐘周期，這取決于CPU。當使用傳統的x87浮點寄存器時，浮點數比較操作，和浮點數到整數的轉換操作，效率較低。

注意：

同一個表達式中，不要混合使用單精度和雙精度浮點數。

盡量避免整型和浮點型的轉換。

向量寄存器支持多種模式，可以根據實際需要設置不同的模式，例如flush-to-zero模式、denormals-are-zero模式等。

枚舉

枚舉其實就是個偽裝的整數，它的效率與整數相同。注意，枚舉值名字可能與一些變量或函數的名字發生沖突，可以將頭文件中的枚舉設置成較長且唯一的名字，或者放入命名空間，也可以使用enum class聲明枚舉。

布爾

布爾操作的順序優化

布爾操作符&&和||的操作數按以下方式計算。如果&&的第一個操作數為false，則根本不計算第二個操作數，因為無論第二個操作數的值是多少，結果都是false。同樣，如果||的第一個操作數為true，則不計算第二個操作數，因為結果肯定是true。

所以，我們可以將通常為true的操作數放在&&表達式的最后，或放在||表達式的最開始。例如，假設a在50%的情況下為真，b在10%的情況下為真。當a為真時，表達式a && b需要計算b，這是50%的情況。等價的表達式b && a只需要在b為真時計算a，這只占10%的時間。

如果一個操作數比另一個操作數更可預測，那么將最可預測的操作數放在前面。

如果一個操作數比另一個操作數計算得快，那么將計算得最快的操作數放在前面。

但是，在改變布爾操作數的順序必須要小心：如果操作數的計算有副作用，如果第一個操作數被用來確定第二個操作數是否有效，則不能交換操作數。例如：

unsigned int i; 
const int ARRAYSIZE = 100; 
float list[ARRAYSIZE]; 
if (i < ARRAYSIZE && list[i] > 3) {...} 

這里我們不能交換順序，因為當i>ARRAYSIZE時，list[i]操作是非法的，另一個例子：

if (handle != INVALID_HANDLE_VALUE && WriteFile(handle, ...)) {...} 

同樣，這里我們也不可能交換順序。

布爾值

布爾變量被存儲為8位整數，值為0表示false, 1表示true。此種意義上，布爾變量由多種因素確定，即所有以布爾變量作為輸入的操作符，有可能不只是0和1，而以布爾變量作為輸出的操作符，只能產出0或1的值。這樣可能布爾變量作為輸入的操作效率較低。

舉例來說，對于

bool a, b, c, d; 
c = a && b; 
d = a || b; 

而編譯器可能是這么實現的：

bool a, b, c, d; 
if (a != 0) { 
    if (b != 0) { 
        c = 1; 
    } else { 
        goto cfalse; 
    } 
} else { 
    cfalse: 
    c = 0; 
} 
if (a == 0) { 
    if (b == 0) { 
        d = 0; 
    } else { 
        goto dtrue; 
    } 
} else { 
    dtrue: 
    d = 1; 
} 

當然，這不是最優方式。在錯誤預測的情況下，分支可能還需要很長時間。如果可以確定操作數除了0和1之外，沒有其他值，那么布爾操作的效率會高得多。編譯器沒有做這樣的假設的原因是，如果變量沒有初始化，或者來源未知，那么它們可能有其它的值。如果a和b已經初始化為有效值，或者它們來自產生布爾輸出的值，則可以優化上述代碼。優化后的代碼如下所示：

char a = 0, b = 0, c, d; 
c = a & b; 
d = a | b; 

這里，我們可以使用char(或int)代替bool，以便能夠使用位操作符(&和|)而不是布爾操作符(&&和||)。按位操作符，是只占用一個時鐘周期的單個指令。即使a和b的值不是0或1，OR操作符(|)也可以工作。但如果操作數的值不是0和1，則AND操作符(&)和異或操作符(^)可能會產生不一致的結果。

注意這里有個坑，我們不能使用~代替!，相反，如果確定輸入是0或1，可以通過與1做異或來得到!的值。

舉例：

bool a, b; 
b = !a; 

可以被優化成：

char a = 0, b; 
b = a ^ 1; 

指針和引用

看代碼：

void FuncA(int *p) { 
    *p = *p + 2; 
} 
void FuncB(int &r) { 
    r = r + 2; 
} 

這兩段分別使用指針和引用的代碼，它們實際上做的是相同的事情，具體我們可以看它們編譯后生成的代碼，其實它們的匯編代碼完全相同，區別僅僅是編程風格的問題。

指針優于引用的理由是：

直接看上面的函數體，很明顯看出p是一個指針，但不清楚r是一個引用，還是一個簡單的變量，使用指針讓閱讀代碼的人更清楚地知道發生了什么。

指針的指向可以更改，使用更靈活，還可以用指針做算術運算。

引用優于指針的理由是：

引用比指針更安全，因為在大多數情況下，引用肯定指向一個有效的地址，而且引用的指向不可更改。而對于指針，如果沒有初始化，那指針算術計算超出了有效地址的范圍，或者指針類型轉換為錯誤的類型，那么指針可能是無效的，并導致致命錯誤。

引用對于復制構造函數和重載運算符很有用。

聲明為常量引用的函數形參，可接受表達式作為實參，而指針和非常量引用需要變量。

使用指針或引用訪問變量，可能與直接訪問一樣快。函數中聲明的所有非靜態變量，都存儲在棧上，實際上它們也是通過棧指針進行尋址。同樣的，類中聲明的所有非靜態變量，也是通過隱式的this指針訪問，所以，大多數變量實際上都是通過指針訪問。

使用指針或引用也有缺點，它需要一個額外的寄存器來保存指針或引用的值，而寄存器是一種稀缺資源，特別是在32位模式下。如果寄存器數量不足，那么每次使用指針時都必須從內存中加載，速度就會變慢。

注意指針這里有個坑：即指針的算數運算：

struct A { 
    int a; 
    int b; 
}; 
A *a; 
a = ++a; 
a = ++(char*)a; 

++a和++(void*)a，它們的運算結果是不同的，++a里其實加的值是8，因為A大小是8，++(void*)a里其實加的值是1，因為(char)大小是1。

函數指針

如果目標地址可以預測，通過函數指針調用函數，相比于直接調用函數，要多花幾個時鐘周期。如果函數指針的值，與上次執行語句時相同，則目標地址會被預測成功，而如果函數指針的值發生變化，目標地址很可能會被錯誤預測，預測失敗會導致有多個時鐘周期的延遲。

智能指針

智能指針是一種行為與指針類似的對象。C++11后基本上有兩種智能指針，unique_ptr和shared_ptr，unique_ptr的特點是有且只有一個指針擁有所分配的對象，只有一個對象指針擁有對象的所有權，而shared_ptr的特點是可以有多個指針共同指向同一個對象，顯然shared_ptr比unique_ptr的開銷更大一些。選擇智能指針時可以更多的選擇unique_ptr，編譯器可以做優化，能夠在簡單情況下剝離掉unique_ptr的大部分或者全部開銷，這樣效率就和直接使用new和delete基本相同。一般一個函數內new，需要另一個函數內delete的場景下，可以考慮使用智能指針。但如果在同一個函數內new和delete，且函數體沒有過多的分支，或許就不需要使用智能指針啦。

有時候程序可能需要很多動態分配的小對象，每個對象都有自己的智能指針，這種成本是否較高?你有什么解決方案嗎?可以在留言板里留言哦!