C++各種循環方式梳理及對比之深入到彙編看while和for

0. 寫在最前面

本文持續更新地址：https://haoqchen.site/2020/05/08/all-kind-of-loop-1/

在學習的過程中發現C++有各種各樣的循環方式，比如最基本的:

• for
• while

後面增加的：

• std::for_each
• 基於範圍的for循環
• std::for_each_n
• std::transform

這些循環方式各有特點，調用方式也不同。本文將整理他們的異同，並嘗試比較他們的效率。很多情況下，程序80%的時間會被20%的代碼消耗，而這20%的代碼多爲循環。

如果覺得寫得還不錯，可以找我其他文章來看看哦～～～可以的話幫我github點個讚唄。
你的Star是作者堅持下去的最大動力哦～～～

1. 結論

將結論寫在前面，是因爲深入探究這個東西會又長又臭，很多人沒那個耐心看下去。但你如果能耐心看下去，相信還是會有更深刻的收穫的。

1. for和while的彙編都是一樣的。
2. for中的判斷，最好是將函數的值給一個const型變量，像下面這樣：

   const int size = getSize();
   for (int i = 0; i < size; ++i){
   
   }
   

3. 對於現代編譯器，將i寫在循環外和循環內沒有區別

2. for與while

2.1 for與while的區別

測試代碼：

#include <iostream>

int main (int argc, char** argv)
{
    int i = 0;
    const int data_size = 100;
    int data[data_size] = {0};
    for (; i < data_size; ++i){
        data[i] = i;
    }

    i = 0;
    while(i < data_size){
        data[i] = i;
        ++i;
    }
    return 0;
}

在命令行輸入一下命令

g++ ./objdump.cpp -g # ./objdump.cpp是我的文件，-g輸出調試信息 
objdump -S a.out -M intel # 使用objdump進行彙編分析，-M指定彙編風格

這種彙編分析的好處是能讓C++代碼跟彙編代碼一一對應，但是看起來不夠整體。認真理解了代碼對應後，直接將cpp文件轉成彙編.s文件:

g++ ./objdump.cpp -S -masm=intel -O0 # -S輸出彙編指令，-masm指定彙編風格爲intel

得到彙編文件objdump.s，其中與for和while循環相關的彙編如下：

.L3:
    cmp  DWORD PTR [rbp-424], 99             ; 先將i與99對比
    jg   .L2                                 ; 不符合直接跳轉到下面
    mov  eax, DWORD PTR [rbp-424]            ; 將i移到累加寄存器eax
    cdqe                                     ; 該指令將EAX簽名擴展爲RAX。它是movslq %eax, %rax的簡短形式，與AT&T風格的cltq等效
    mov  edx, DWORD PTR [rbp-424]            ; 將i移到edx寄存器，該寄存器總是用來存放整數除法產生的餘數
    mov  DWORD PTR [rbp-416+rax*4], edx      ; 將edx移到對應的data[i]地址
    add  DWORD PTR [rbp-424], 1              ; i + 1
    jmp  .L3                                 ; 跳回for循環
.L2:
    mov  DWORD PTR [rbp-424], 0
.L5:
    cmp  DWORD PTR [rbp-424], 99
    jg   .L4
    mov  eax, DWORD PTR [rbp-424]
    cdqe
    mov  edx, DWORD PTR [rbp-424]
    mov  DWORD PTR [rbp-416+rax*4], edx
    add  DWORD PTR [rbp-424], 1
    jmp  .L5
.L4:
    mov  eax, 0
    mov  rsi, QWORD PTR [rbp-8]
    xor  rsi, QWORD PTR fs:40
    je  .L7
    call  __stack_chk_fail

可以看到，while和for的彙編都是一樣的，性能也就肯定一樣啦。

2.2 for中的判斷應該怎麼寫

// A
for (int i = 0; i < vec.size(); ++i){

}
// B
const int size = vec.size();
for (int i = 0; i < size; ++i){

}

for裏面有一個判斷條件，經常會糾結，到底是A好，還是B好。

測試代碼：

#include <iostream>

const int kDataSize = 100;
int data_size = 100;

const int getSize(void)
{
    return kDataSize;
}

int main (int argc, char** argv)
{
    int data[kDataSize] = {0};
    for (int i = 0; i < getSize(); ++i){
        data[i] = i;
    }

    for (int i = 0; i < kDataSize; ++i){
        data[i] = i;
    }

    for (int i = 0; i < data_size; ++i){
        data[i] = i;
    }
    return 0;
}

生成主要彙編代碼如下：

    .globl  _Z7getSizev                             ; getSize函數，LFB是函數開始，LFE是函數結尾，LBB和LBE是功能塊
    .type  _Z7getSizev, @function
_Z7getSizev:
.LFB1021:
    .cfi_startproc
    push  rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    mov   rbp, rsp
    .cfi_def_cfa_register 6
    mov   eax, 100
    pop   rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE1021:
    .size  _Z7getSizev, .-_Z7getSizev

    mov   DWORD PTR [rbp-428], 0
.L5:                                                   ; 調用函數的for循環
    call  _Z7getSizev                                  ; 每個for循環都要調用函數，造成浪費
    cmp   eax, DWORD PTR [rbp-428]                     ; 比較函數結果（在函數內被放到了eax）與i的大小  
    ; eax是32位寄存器，ax是eax的低16位，ah是ax的高8位，al是ax的低8位。
    setg  al                                           ; setg al ; ZF==0 並 SF==0 並 OF==0 時 al=1;
    ; test會根據操作數運算設置加法器相關標誌位，一般用來判斷操作數是否爲0
    test  al, al                                       ; al和al兩個操作數進行按位與操作，al本身不變
    je    .L4                                          ; 等於則跳轉
    mov   eax, DWORD PTR [rbp-428]
    cdqe
    mov   edx, DWORD PTR [rbp-428]
    mov   DWORD PTR [rbp-416+rax*4], edx
    add   DWORD PTR [rbp-428], 1
    jmp   .L5
.L4:
    mov   DWORD PTR [rbp-424], 0
.L7:                                                   ; 與2.1節一樣
    cmp   DWORD PTR [rbp-424], 99
    jg    .L6                                          ; 有符號大於則跳轉
    mov   eax, DWORD PTR [rbp-424]
    cdqe
    mov   edx, DWORD PTR [rbp-424]
    mov   DWORD PTR [rbp-416+rax*4], edx
    add   DWORD PTR [rbp-424], 1
    jmp   .L7
.L6:
    mov   DWORD PTR [rbp-420], 0
.L9:
    mov   eax, DWORD PTR data_size[rip]                ; 比上一個for多了將data_size移到eax這一步
    cmp   DWORD PTR [rbp-420], eax
    jge   .L8                                          ; 有符號大於等於則跳
    mov   eax, DWORD PTR [rbp-420]
    cdqe
    mov   edx, DWORD PTR [rbp-420]
    mov   DWORD PTR [rbp-416+rax*4], edx
    add   DWORD PTR [rbp-420], 1
    jmp   .L9

總結：

1. L7和L9，也即後面兩個循環，一個是const int， 一個是int類型的變量。L7跟前面2.1是完全一樣的，L9由於不是const變量，所以必須要每次都讀取到eax寄存器中，多了一步。
2. 如果判斷條件是函數，將會額外進行非常多的操作。
3. 對比,2.1和2.2可以發現，將i放在循環內還是循環外，在現代編譯器看來都是一樣的。

參考

• 文中用到的一些鏈接

喜歡我的文章的話Star一下唄Star

版權聲明：本文爲白夜行的狼原創文章，未經允許不得以任何形式轉載