C之函數與宏（四十）

        在 C 語言中，我們經常會遇到函數和宏，那么我們今天就來分析下函數與宏。

        我們先來看看函數與宏有什么區別：a> 宏是由預處理期直接替換展開的，編譯器不知道宏的存在；b> 函數是由編譯器直接編譯的實體，調用行為由編譯器決定；c> 多次使用宏會導致最終可執行程序的體積增大；d> 函數是跳轉執行的，內存中只有一份函數體存在；e> 宏的效率比函數要高，因為是直接展開，沒有調用開銷；f> 函數調用時會創建活動記錄，效率不如宏。

下來我們以代碼為例進行分析，代碼如下

#include <stdio.h>

#define RESET(p, len)          \
    while( len > 0 )           \
        ((char*)p)[--len] = 0

void reset(void* p, int len)
{
    while( len > 0 ) 
        ((char*)p)[--len] = 0;
}

int main()
{
    int array[] = {1, 2, 3, 4, 5};
    int len = sizeof(array);
    int i = 0;
    
    RESET(array, len);
         
    //reset(array, len);
    
    for(i=0; i<5; i++)
    {
        printf("array[%d] = %d\n", i, array[i]);
    }
    
    return 0;
}

        我們先來看看這份程序，它是分別利用宏和函數來實現 reset 功能。我們先來用宏來實現，注釋掉第 21 行。編譯后結果如下

        我們再來注釋掉第19行，用函數來實現看看

        那么我們看到兩個編譯結果是一樣的，如果我們將宏調用和函數調用中的 array 寫成了 整數 6 呢？宏調用是不會報錯的，因為它是直接的文本替換，而函數調用會提示。所以在宏和函數都能完成的前提下，我們盡量使用函數來完成。因為編譯器會自動的檢查函數是否正確，盡量保證 我們的程序最高的安全性。我們來看看編譯效果

        我們看到直接編譯宏的時候，它沒報錯，但是運行的時候直接發生段錯誤。但是在編譯函數時，它報了一個警告。因為我們直接改變的是低地址處，屬于內核處，直接改變的話會導致段錯誤。由此看來，在相同的情況下，我們最好使用函數，安全性較高。

        宏的效率比函數稍高，但是其副作用巨大；宏是文本替換，參數無法進行類型檢查；可以用函數完成的功能絕對不用宏；宏的定義中不能出現遞歸定義；

        下來我們再以一個示例代碼看看宏的副作用

#include <stdio.h>
 
#define _ADD_(a, b) a + b
#define _MUL_(a, b) a * b
#define _MIN_(a, b) ((a) < (b) ? (a) : (b))
 
int main()
{
    int i = 1;
    int j = 10;
    
    printf("%d\n", _MUL_(_ADD_(1, 2), _ADD_(3, 4)));
    printf("%d\n", _MIN_(i++, j));
    
    return 0;
}

        我們來分析下這個代碼，第12行應該是 (1+2) * (3+4) = 21；第13行應該是 1 < 10 ? 1 : 10；應該是1。我們來看下編譯結果

        我們看到程序打印出的是 11 和 2，和我們分析的不一致。我們再來單步編譯下，看看編譯器處理成什么樣了

        那么我們看到這樣的處理，那個結果也就不奇怪了。這便是宏的副作用，既然宏的副總用這么大，我們為何還要使用宏呢？宏的妙用在于它可以生成一些常規性的代碼，封裝函數可加上類型信息。我們再以下面的示例代碼進行分析

#include <stdio.h>
#include <malloc.h>
 
#define MALLOC(type, x)   (type*)malloc(sizeof(type)*x)
#define FREE(p)           (free(p), p=NULL)
 
#define LOG_INT(i)        printf("%s = %d\n", #i, i)
#define LOG_CHAR(c)       printf("%s = %c\n", #c, c)
#define LOG_FLOAT(f)      printf("%s = %f\n", #f, f)
#define LOG_POINTER(p)    printf("%s = %p\n", #p, p)
#define LOG_STRING(s)     printf("%s = %s\n", #s, s)
 
#define FOREACH(i, n)     while(1) { int i = 0, l = n; for(i=0; i < l; i++)
#define BEGIN             {
#define END               } break; } 
 
int main()
{
    int* pi = MALLOC(int, 5);
    char* str = "hello, world";
    
    LOG_STRING(str);
    
    LOG_POINTER(pi);
    
    FOREACH(k, 5)
    BEGIN
        pi[k] = k + 1;
    END
    
    FOREACH(n, 5)
    BEGIN
        int value = pi[n];
        LOG_INT(value);
    END
    
    FREE(pi);
    
    LOG_POINTER(pi);
    
    return 0;
}

        我們在第 4 行用宏定義實現了申請指定大小帶類型的空間，接著在第 5 行實現了刪除指針并指向空的操作。這樣的操作是在函數中所不能實現的，接著下面幾行是分別打印他們的值。第 13 行之后便是實現了打印一個 for 循環。我們在 main 函數中，第 19 行申請了 5 個 int 類型大小的空間，第 22 行應該打印出 hello, world，第 24 行打印出它的地址，接著給之前申請的堆空間賦值。再將他們的值賦值給 value，第 37 行釋放指針 pi，最后打印指針的值便會是 NULL 了。我們來看看編譯結果

        我們看到確實如我們所分析的那樣。通過對宏和函數的學習，總結如下：1、宏和函數并不是競爭對手；2、宏能接受任何類型的參數，效率高，但易出錯；3、函數的參數必須是固定類型，效率稍低，但安全性高；4、宏可以實現函數不能實現的功能。