C語言中的宏和函數(shù)是非常相似的，它們都可以完成類似的功能。比如，想要求2個(gè)數(shù)的較大值，使用宏的寫法是：

// 宏的定義
#define MAX(x, y) ((x)>(y)?(x):(y))

// 使用
int m = MAX(10, 20);

使用函數(shù)的寫法是：

// 函數(shù)的定義
int Max(int x, int y)
{
	return x>y ? x : y;
}

// 使用
int m = Max(10, 20);

既然宏和函數(shù)長的那么像，究竟什么時(shí)候用宏，什么時(shí)候用函數(shù)呢？這就要了解一下它們之間的區(qū)別了。我總結(jié)了他倆之間的區(qū)別，主要體現(xiàn)在以下幾點(diǎn)：

1.代碼長度。

2.執(zhí)行速度。

3.操作符優(yōu)先級。

4.帶有副作用的參數(shù)。

5.參數(shù)類型。

6.調(diào)試。

7.遞歸。

8.命名約定。

9.其他。

1.代碼長度

宏會在每個(gè)使用它的地方替換。比如前面提到的求兩個(gè)數(shù)的較大值的宏，假設(shè)這么使用：

int m = MAX(10, 20);
// ...
m = MAX(20, 30)
// ...
m = MAX(30, 40);
// ...
// ...

每個(gè)使用宏的地方都會被替換掉。

int m = ((10)>(20)?(10):(20));
// ...
m = ((20)>(30)?(20):(30))
// ...
m = ((30)>(40)?(30):(40));
// ...
// ...

這里的宏體比較短，所以替換進(jìn)去后，代碼的長度并沒有明顯的提升。但是，假設(shè)這個(gè)宏有100行代碼，每個(gè)地方展開后，展開3次，就會多出300行代碼。如果更加頻繁的調(diào)用，調(diào)用100次，就會多出10000行代碼。所以，當(dāng)宏體比較長，尤其是調(diào)用次數(shù)還比較多的情況下，會導(dǎo)致代碼長度大大增加。

而函數(shù)就不存在這個(gè)問題，函數(shù)不管調(diào)用幾次，都只需要寫一次函數(shù)的代碼，每次使用時(shí)直接調(diào)用即可，代碼長度是可控的。

2.執(zhí)行速度

函數(shù)調(diào)用時(shí)，需要在?？臻g上開辟一塊棧幀，參數(shù)還要壓棧。當(dāng)函數(shù)體的代碼執(zhí)行完后，需要返回時(shí)，還要銷毀棧幀。這些都是有開銷的，執(zhí)行速度較慢。

但是，宏的代碼在預(yù)處理階段就已經(jīng)完成替換，不存在這個(gè)問題，執(zhí)行速度較快。

3.操作符優(yōu)先級

使用宏時(shí)，代碼是在對應(yīng)的位置直接展開，如果該位置周圍有其他操作符，有可能干擾宏體內(nèi)的操作符的執(zhí)行順序，導(dǎo)致錯誤的結(jié)果。比如：

#define DOUBLE(x) x+x

如果這么調(diào)用：

int ret = 2 * DOUBLE(10);

我們想的是：DOUBLE(10)會算出20，再乘2，得到40。然而，實(shí)際代碼會這樣展開：

int ret = 2 * 10+10;

由于乘號的優(yōu)先級比較高，會先算2*10，得到20，再加10得到30，和預(yù)期的結(jié)果不一致。

但函數(shù)不存在這個(gè)問題。

int Double(int x)
{
    return x+x;
}

當(dāng)這樣調(diào)用時(shí)：

int ret = 2 * Double(10);

一定是先把10傳給函數(shù)，函數(shù)計(jì)算完后返回20，再進(jìn)行別的計(jì)算。

當(dāng)然，如果參數(shù)本身是表達(dá)式時(shí)，也會有相同的問題。比如：

#define SQUARE(x) x*x

int Square(int x)
{
    return x*x;
}

int ret1 = SQUARE(3 + 2);
int ret2 = Square(3 + 2);

函數(shù)就是正常的，先計(jì)算3+2得到5，在把5傳參，得到25。但是宏會這樣替換：

int ret1 = 3 + 2*3 + 2;

由于乘號的優(yōu)先級較高，得到的結(jié)果就是11，和預(yù)期結(jié)果不符。

為了解決這樣的問題，建議寫宏時(shí)多加括號，防止受到其他操作符的影響。比如：

#define DOUBLE(x) ((x)+(x))
#define SQUARE(x) ((x)*(x))

4.帶有副作用的參數(shù)

對于MAX宏，如果這樣使用：

int x = 3;
int y = 5;
int m = MAX(x++, y++);

我們的想法是：把x和y傳參，算出x和y的較大值為5，即m應(yīng)該是5，而后置++會把x和y的值分別改成4和6。但是實(shí)際替換時(shí)是這么替換的：

int m = ((x++)>(y++)?(x++):(y++));

計(jì)算時(shí)，先判斷x++>y++這個(gè)表達(dá)式，顯然x<y，故為假，判斷完后x和y都要++，x改成4，y改成6，返回y++的結(jié)果，即6，y再++改成7。所以最終結(jié)果是：m為6，x為4，y為7，和預(yù)期不符，原因是帶有副作用的宏參數(shù)影響了結(jié)果。

函數(shù)就不存在這個(gè)問題。如果調(diào)用Max函數(shù)：

int x = 3;
int y = 5;
int m = Max(x++, y++);

由于函數(shù)的傳參和函數(shù)體代碼的執(zhí)行是分開的，所以結(jié)果和預(yù)期相同，m=5, x=4, y=6。

5.參數(shù)類型

宏是直接對代碼進(jìn)行文本替換，是不檢查類型的。比如：

int m1 = MAX(3, 5);// 會被替換成int m1 = ((3)>(5)?(3):(5));
double m2 = MAX(3.2, 5,3); // 會被替換成double m2 = ((3.2)>(5.3)?(3.2):(5.3));

但是函數(shù)的形參是有類型的，傳參時(shí)會對類型進(jìn)行檢查。比如前面的Max函數(shù)，參數(shù)列表是(int, int)，只能求2個(gè)整數(shù)的較大值，如果要求兩個(gè)浮點(diǎn)數(shù)的較大值，是無能為力的。

6.調(diào)試

宏直接完成代碼的替換，不方便調(diào)試。因?yàn)楹甑奶鎿Q在預(yù)處理階段已經(jīng)完成，但是調(diào)試時(shí)調(diào)試的是最終生成的可執(zhí)行程序。由于已經(jīng)完成了替換，看到的代碼和調(diào)試的代碼是不一樣的。函數(shù)就沒有這個(gè)問題，可以逐語句調(diào)試。

7.遞歸

宏不能遞歸，函數(shù)可以實(shí)現(xiàn)遞歸。

8.命名約定

一般宏的名字為全大寫，函數(shù)名不會全大寫。比如：

宏名：MAX, DOUBLE, SQUARE。

函數(shù)名：Max, Double, Square。

但是也有例外。比如庫中的offsetof是一個(gè)宏，而不是函數(shù)。

9.其他

宏可以實(shí)現(xiàn)直接把參數(shù)轉(zhuǎn)換成字符串，或者把兩個(gè)標(biāo)識符連起來。具體可以看我之前寫的這篇博客：你知道C語言中的#和##分別是什么意思嗎？

總結(jié)

1.宏的代碼長度較長，因?yàn)闀欢啻翁鎿Q。函數(shù)只存一份代碼，長度較短。

2.函數(shù)調(diào)用和返回都有開銷，速度較慢。宏速度較快。

3.宏會受到操作符優(yōu)先級的影響，導(dǎo)致結(jié)果可能和預(yù)期不符，函數(shù)沒有這個(gè)問題。解決方案：寫宏時(shí)，最好多加括號來限定操作符的執(zhí)行順序。

4.宏有可能受到帶有副作用的參數(shù)的影響，函數(shù)無此影響。

5.函數(shù)有參數(shù)類型檢查，宏沒有。

6.宏不方便調(diào)試，函數(shù)無此問題。

7.函數(shù)可以遞歸，宏不可以。

8.宏名一般全大寫，函數(shù)一般不會全大寫。

9.宏可以實(shí)現(xiàn)一些函數(shù)實(shí)現(xiàn)不了的操作，比如把參數(shù)直接轉(zhuǎn)換成字符串，連接2個(gè)標(biāo)識符等。

根據(jù)以上幾點(diǎn)，一般來說，一些簡單的邏輯可以使用宏實(shí)現(xiàn)，比如求2個(gè)數(shù)的較大值。但是當(dāng)代碼長度比較長，或者邏輯比較復(fù)雜時(shí)，建議使用函數(shù)實(shí)現(xiàn)。

以上就是C語言中宏和函數(shù)的9個(gè)區(qū)別詳解的詳細(xì)內(nèi)容，更多關(guān)于C語言宏 函數(shù)的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論