執行結果為下：

0
0.047
非內聯:49999 + 49999 = 99998
執行非內聯的sum1的時間為：0.014
內聯:49999 + 49999 = 99998
執行內聯的sum2的時間為：0.006
巨集:49999 + 49999 = 99998
執行巨集的_SUM的時間為：0.004

老爺機，效能比較差，但結果比較明顯，巨集>行內函數>普通函式

原因下面分析：

寫個最簡單的測試程式：

test1.c    這個測試下巨集

#include<stdio.h>

#define _SUM(x,y) x+y

void main()
{
   printf("%d\n",_SUM(5,6));
}

對test1.c執行預編譯 :

#gcc -E test1.c -o test1.i

得到下面結果  test1.i

...以上省略啊（包含的標頭檔案加進來）

# 2 "test1.c" 2



void main()
{
   printf("%d\n",5 +6);
}

由此可見，在預編譯時期，巨集被展開了

再將預編譯後的檔案test1.i 進行編譯

gcc –S test1.i –o test1.s

得到以下結果： test1.S

    .file    "test1.c"
    .section    .rodata
.LC0:
    .string    "%d\n"
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $.LC0, %eax
    movl    $11, 4(%esp)       #在這裡我們的表示式在編譯時期計算出來，並轉換為了立即數
    movl    %eax, (%esp)
    call    printf
    leave
    ret
    .size    main, .-main
    .ident    "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

巨集表示式被轉換成了立即數

下面是測試程式碼2：普通函式的

test2.c

#include<stdio.h>

int sum(int x,int y)
{
   return x+y;
}

void main()
{
    printf("%d\n",sum(5,6));
}

同樣將其預編譯：

gcc -E test2.c -o test2.i

得到下面程式碼：

....

# 2 "test2.c" 2

int sum(int x,int y)
{
   return x+y;
}

void main()
{
    printf("%d\n",sum(5,6));
}

再將其編譯：

gcc -S test2.i -o test2.S

得到下面程式碼：

    .file    "test2.c"
    .text
.globl sum
    .type    sum, @function
sum:
    pushl    %ebp
    movl    %esp, %ebp
    movl    12(%ebp), %eax
    movl    8(%ebp), %edx
    leal    (%edx,%eax), %eax
    popl    %ebp
    ret
    .size    sum, .-sum
    .section    .rodata
.LC0:
    .string    "%d\n"
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $6, 4(%esp)
    movl    $5, (%esp)
    call    sum                             #在這個地方產生了函式呼叫，也是使程式執行速度下降的原因
    movl    $.LC0, %edx
    movl    %eax, 4(%esp)
    movl    %edx, (%esp)
    call    printf
    leave
    ret
    .size    main, .-main
    .ident    "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

可見上面程式產生了函式掉用，即引數的壓棧

下面是測試程式碼3:測試行內函數的

test3.c

#include<stdio.h>

inline int sum(int x, int y) __attribute__((always_inline)); //注意這裡加上編譯屬性，讓編譯器始終展開此行內函數，否則編譯出來後跟普通函式沒啥區別

inline int sum(int x, int y)
{
    return x + y;
}

void main()
{
    printf("%d\n",sum(5,6));
}

同樣先預編譯：

gcc -E test3.c -o test3.i

得到下面程式碼： test3.i

....

# 2 "test3.c" 2

inline int sum(int x, int y) __attribute__((always_inline));

inline int sum(int x, int y)
{
    return x + y;
}

void main()
{
    printf("%d\n",sum(5,6));
}

由此可見，行內函數的展開不管預編譯的事情，明顯是在編譯時展開的

下面將 test3.i編譯

gcc -S tets3.i -o test3.S

得到下面的程式碼 test3.S:

    .file    "test4.c"
    .text
.globl sum
    .type    sum, @function
sum:
    pushl    %ebp
    movl    %esp, %ebp
    movl    12(%ebp), %eax
    movl    8(%ebp), %edx
    leal    (%edx,%eax), %eax
    popl    %ebp
    ret
    .size    sum, .-sum
    .section    .rodata
.LC0:
    .string    "%d\n"
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $32, %esp
    movl    $5, 28(%esp)
    movl    $6, 24(%esp)
    movl    24(%esp), %eax
    movl    28(%esp), %edx
    leal    (%edx,%eax), %eax  #這裡可以看出，沒有產生函式呼叫，而是將sum的程式碼展開在此
    movl    %eax, %edx
    movl    $.LC0, %eax
    movl    %edx, 4(%esp)
    movl    %eax, (%esp)
    call    printf
    leave
    ret
    .size    main, .-main
    .ident    "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

上面可以清楚的看到，編譯器將行內函數展開到了函式的調用出，並減少了函式呼叫產生的效率和壓棧操作，所以效率比普通函式呼叫要高一些

但是比起巨集直接轉換為立即數肯定還是要低點，畢竟行內函數展開後，程式碼量都比巨集展開的多，很明顯。而巨集的話在預編譯的時候就已經被展開了，在編譯時期就是

當成一個普通表示式處理，而無關任何函式呼叫的事情。

好，現在已經論證完，巨集，普通函式，行內函數的差異，以及三者的執行速度問題了。關於三者什麼時候用，什麼情況下用，後面再討論吧。