宏替換預編譯

Ⅰ 宏替換，宏展開到底分別在什麼時候進行

//在宏 使用的時候 分為

宏定義 和 宏展開， 你那個 宏替換就是展開

宏定義是你自己寫的 #define
然後展開在預編譯時候處理
這個時候編譯器先掃描一遍文件 把用到宏的地方都做字元替換

比如
#define M 1

int a = M;
那麼預編譯的時候就把 M 替換成1

注意宏只做文本替換，所以
比如 #define MUL(__x__, __y__) __x__ * __y__

int a = MUL(a + b, c+ d);
會被替換成 int a = a + b * c + d // 可能就會和初衷違背（如果你想做的是 (a + b) * (c + b)）

從展開的角度來說 因為宏是可以嵌套的 所以宏在替換的時候 我們叫做展開

比如 做一個函數參數聲明
#define PARAMS_SET_1(__type__, __name__) __type__ __name__
#define PARAMS_SET_2(__type__, __name__) __type__ __name__##1, __type__ __name__##2

//... 定義N個 PARAMS_SET_N
#define PARAMS(__size__, __type__, __name__) PARAMS_SET_##__size__(__type__, __name__)

然後 定義函數

int foo(PARAMS(2, int, n));
那麼預編譯的時候宏會這樣展開

1， int foo(PARAMS_SET_2(int, n));
2, int foo(int n1, int n2);

另外注意就是編程的時候 由於宏只是文本替換，缺少類型檢測 以及運算順序這樣的功能，所以要少用宏

上面所有的宏都有替換的方案
#define M 1 替換方案
struct M
{enum {value = 1} };
int a = M::value;

#define MUL(__x__, __y__) __x__ * __y__ 替換方案
template<int x, int y>
struct MUL
{enum{value = x * y}};

int a = MUL<10 + 20, 10 + 30>::value;

最後一個PARAMS的替換方案就是函數重載
template<typename T>
int foo(T n1);

template<typename T>
int foo(T n1, Tn2);

//後面定義N個

Ⅱ 什麼是預編譯，何時需要預編譯

預編譯又稱為預處理，是做些代碼文本的替換工作

預編譯又稱為預處理,是做些代碼文本的替換工作

處理#開頭的指令,比如拷貝#include包含的文件代碼，#define宏定義的替換,條件編譯等

就是為編譯做的預備工作的階段

主要處理#開始的預編譯指令

預編譯指令指示了在程序正式編譯前就由編譯器進行的操作，可以放在程序中的任何位置。常見的預編譯指令有：

(1)#include 指令

該指令指示編譯器將xxx.xxx文件的全部內容插入此處。若用<>括起文件則在系統的INCLUDE目錄中尋找文件，若用" "括起文件則在當前目錄中尋找文件。一般來說，該文件是後綴名為"h"或"cpp"的頭文件。

注意：<>不會在當前目錄下搜索頭文件，如果我們不用<>而用""把頭文件名擴起，其意義為在先在當前目錄下搜索頭文件，再在系統默認目錄下搜索。

(2)#define指令

該指令有三種用法:

第一種是定義標識，標識有效范圍為整個程序，形如#define XXX，常與#if配合使用；

第二種是定義常數，如#define max 100，則max代表100（這種情況下使用const定義常數更好，原因見注1）；

第三種是定義"函數"，如#define get_max(a, b) ((a)>(b)?(a):(b)) 則以後使用get_max(x,y)就可以得到x和y中較大的數（這種方法存在一些弊病，見注2）。

第四種是定義"宏函數"，如#define GEN_FUN(type) type max_##type(type a,type b){return a>b?a:b;} ，使用時，用GEN_FUN(int)，則此處預編譯後就變成了 max_int(int a,int b){return a>b?a:b;},以後就可以使用max_int(x,y)就可以得到x和y中較大的數.比第三種，增加了類型的說明。

(3)#if、#else和#endif指令

這些指令一般這樣配合使用：

#if defined(標識) //如果定義了標識

要執行的指令

#else

要執行的指令

#endif

在頭文件中為了避免重復調用(比如說兩個頭文件互相包含對方)，常採用這樣的結構：

#if !(defined XXX) //XXX為一個在你的程序中唯一的標識符，

//每個頭文件的標識符都不應相同。

//起標識符的常見方法是若頭文件名為"abc.h"

//則標識為"abc_h"

#define XXX

真正的內容，如函數聲明之類

#endif

Ⅲ c語言中的宏定義是什麼意思可不可以詳細的解釋一下～

宏定義又稱為宏代換、宏替換，簡稱「宏」。
格式：
#define
標識符
字元串
其中的標識符就是所謂的符號常量，也稱為「宏名」。
預處理（預編譯）工作也叫做宏展開：將宏名替換為字元串。
掌握"宏"概念的關鍵是「換」。一切以換為前提、做任何事情之前先要換，准確理解之前就要「換」。
即在對相關命令或語句的含義和功能作具體分析之前就要換：
例：
#define
pi
3.1415926
把程序中出現的pi全部換成3.1415926

Ⅳ 預處理命令的宏定義

1.不帶參數的宏定義：
宏定義又稱為宏代換、宏替換，簡稱「宏」。
格式：
#define標識符文本
其中的標識符就是所謂的符號常量，也稱為「宏名」。
預處理（預編譯）工作也叫做宏展開：將宏名替換為文本（這個文本可以是字元串、可以是代碼等）。
掌握宏概念的關鍵是「換」。一切以換為前提、做任何事情之前先要換，准確理解之前就要「換」。
即在對相關命令或語句的含義和功能作具體分析之前就要換：
例：
#define PI 3.1415926
把程序中全部的標識符PI換成3.1415926
說明：
（1）宏名一般用大寫
（2）使用宏可提高程序的通用性和易讀性，減少不一致性，減少輸入錯誤和便於修改。例如：數組大小常用宏定義
（3）可以用#undef命令終止宏定義的作用域
（4）宏定義可以嵌套
2.帶參數的宏：
除了一般的字元串替換，還要做參數代換
格式：
#define 宏名（參數表）文本
例如：#define S(a,b) a*b
area=S(3,2)；第一步被換為area=a*b; ，第二步被換為area=3*2;
類似於函數調用，有一個啞實結合的過程：
（1）實參如果是表達式容易出問題
#define S(r) r*r
area=S(a+b);第一步換為area=r*r;,第二步被換為area=a+b*a+b;
正確的宏定義是#define S(r) ((r)*(r))
（2）宏名和參數的括弧間不能有空格
（3）宏替換只作替換，不做計算，不做表達式求解
（4）函數調用在編譯後程序運行時進行，並且分配內存。宏替換在編譯前進行，不分配內存
（5）宏的啞實結合不存在類型，也沒有類型轉換。
（6）宏展開使源程序變長，函數調用不會
（7）宏展開不佔運行時間，只佔編譯時間，函數調用占運行時間（分配內存、保留現場、值傳遞、返回值）

Ⅳ 譚浩強的書上說宏替換不佔運行時間,只佔編譯時間,可宏替換不是在預處理時就解決了么不會佔用編譯時間吧

不佔用
程序從源碼到可執行文件，主要包括以下幾個過程：預處理器進行預處理（預處理器），接著有時候可能進行預編譯，接著是編譯（編譯器），接著是連接（連接器）（產生可執行文件）。不過現在的好多集成平台都把前面三步放到一起了。

Ⅵ C語言中，下面有關宏替換的敘述中，不正確的是

宏替換是在預編譯時完成的，預編譯的功能是將頭文件引入，並且將定義的宏按字面完成「傻瓜」式替換（即將符合宏的樣式的字元串，替換成宏定義的字元串），宏名沒有類型區分，它只是個字元串。因此，D是錯的

Ⅶ c語言中宏替換時先求出實參表達式的值,然後再帶入形參中運算求值，對不對啊為什麼啊

不是這樣的，宏替換是在預編譯時將整個宏的表達式進行替換再進行編譯的，舉個例子講如果你定義了如下宏：
#define fun(a) （a*a）
下面用的時候
int main()
{
int i = 5, j = 4;
int k = fun(i+j)
}
那麼在預編譯時首選會先將fun(i+j)替換成 i+j*i+j,即此時計算的時候會先算乘法i*j，那麼k的值最終就是5+4*5+4 = 29,而不是(i+j)*(i+j)=81,當然如果你想實現後一種結果，則宏定義方法應該是下面這樣的
#define fun(a) ((a)*(a))

相互學習，希望對你有幫助，不懂的話，再跟我討論吧

Ⅷ 宏替換只是字元替換,不佔用編譯時間是不是正確

宏是在預編譯期間進行的，將代碼中的指定字元轉換
轉換結束後，再進行編譯
所以不佔用編譯時間

Ⅸ C語言中，宏替換的替換規則

簡單來說：宏定義又稱為宏代換、宏替換，簡稱「宏」。是C提供的三種預處理功能的其中一種。

復雜的請看下面，講的很全。下面的帶參宏定義，多行宏定義，在Linux內核源碼中很多。另外sizeof也是一個宏定義。

宏定義

宏定義是C提供的三種預處理功能的其中一種，這三種預處理包括：宏定義、文件包含、條件編譯

1. 不帶參數的宏定義：

宏定義又稱為宏代換、宏替換，簡稱「宏」。

格式： #define 標識符 字元串

其中的標識符就是所謂的符號常量，也稱為「宏名」。

預處理（預編譯）工作也叫做宏展開：將宏名替換為字元串。

掌握"宏"概念的關鍵是「換」。一切以換為前提、做任何事情之前先要換，准確理解之前就要「換」。

即在對相關命令或語句的含義和功能作具體分析之前就要換：

例： #define PI 3.1415926 把程序中出現的PI全部換成3.1415926

說明：

（1）宏名一般用大寫

（2）使用宏可提高程序的通用性和易讀性，減少不一致性，減少輸入錯誤和便於修改。例如：數組大小常用宏定義

（3）預處理是在編譯之前的處理，而編譯工作的任務之一就是語法檢查，預處理不做語法檢查。

（4）宏定義末尾不加分號；

（5）宏定義寫在函數的花括弧外邊，作用域為其後的程序，通常在文件的最開頭。

（6）可以用#undef命令終止宏定義的作用域

（7）宏定義可以嵌套

（8）字元串" "中永遠不包含宏

（9）宏定義不分配內存，變數定義分配內存。

2. 帶參數的宏定義：

除了一般的字元串替換，還要做參數代換

格式： #define 宏名（參數表） 字元串

例如：#define S（a,b） a*b

area=S（3,2）；第一步被換為area=a*b; ，第二步被換為area=3*2;

類似於函數調用，有一個啞實結合的過程：

（1）實參如果是表達式容易出問題

#define S（r） r*r

area=S（a+b）；第一步換為area=r*r;,第二步被換為area=a+b*a+b;

正確的宏定義是#define S（r） （（r）*（r））

（2）宏名和參數的括弧間不能有空格

（3）宏替換只作替換，不做計算，不做表達式求解

（4）函數調用在編譯後程序運行時進行，並且分配內存。宏替換在編譯前進行，不分配內存

（5）宏的啞實結合不存在類型，也沒有類型轉換。

（6）函數只有一個返回值，利用宏則可以設法得到多個值

（7）宏展開使源程序變長，函數調用不會

（8）宏展開不佔運行時間，只佔編譯時間，函數調用占運行時間（分配內存、保留現場、值傳遞、返回值）

3. 宏定義其他冷門、重點知識

#define用法

1、 用無參宏定義一個簡單的常量

#define LEN 12

這個是最常見的用法，但也會出錯。

比如下面幾個知識點你會嗎？可以看下：

（1） #define NAME "zhangyuncong"

程序中有"NAME"則，它會不會被替換呢？

（2） #define 0x abcd

可以嗎？也就是說，可不可以用把標識符的字母替換成別的東西？

（3） #define NAME "zhang

這個可以嗎？

（4） #define NAME "zhangyuncong"

程序中有上面的宏定義，並且，程序里有句：

NAMELIST這樣，會不會被替換成"zhangyuncong"LIST

四個題答案都是否定的。

第一個，""內的東西不會被宏替換。這一點應該大都知道。

第二個，宏定義前面的那個必須是合法的用戶標識符

第三個，宏定義也不是說後面東西隨便寫，不能把字元串的兩個""拆開。

第四個：只替換標識符，不替換別的東西。NAMELIST整體是個標識符，而沒有NAME標識符，所以不替換。

也就是說，這種情況下記住：#define 第一位置第二位置

（1） 不替換程序中字元串里的東西。

（2） 第一位置只能是合法的標識符（可以是關鍵字）

（3） 第二位置如果有字元串，必須把""配對。

（4） 只替換與第一位置完全相同的標識符

還有就是老生常談的話：記住這是簡單的替換而已，不要在中間計算結果，一定要替換出表達式之後再算。

2、 帶參宏一般用法

比如#define MAX（a,b） （（a）>（b）？（a）：（b））

則遇到MAX（1+2,value）則會把它替換成：

（（1+2）>（value）？（1+2）：（value））

注意事項和無參宏差不多。

但還是應注意

#define FUN（a） "a"

則，輸入FUN（345）會被替換成什麼？

其實，如果這么寫，無論宏的實參是什麼，都不會影響其被替換成"a"的命運。

也就是說，""內的字元不被當成形參，即使它和一模一樣。

那麼，你會問了，我要是想讓這里輸入FUN（345）它就替換成"345"該怎麼實現呢？

請看下面關於#的用法

3、 有參宏定義中#的用法

#define STR（str） #str

#用於把宏定義中的參數兩端加上字元串的""

比如，這里STR（my#name）會被替換成"my#name"

一般由任意字元都可以做形參，但以下情況會出錯：

STR（））這樣，編譯器不會把「）」當成STR（）的參數。

STR（，）同上，編譯器不會把「，」當成STR的參數。

STR（A,B）如果實參過多，則編譯器會把多餘的參數捨去。（VC++2008為例）

STR（（A,B））會被解讀為實參為：（A,B），而不是被解讀為兩個實參，第一個是（A第二個是B）。 4、 有參宏定義中##的用法

#define WIDE（str） L##str

則會將形參str的前面加上L

比如：WIDE（"abc"）就會被替換成L"abc"

如果有#define FUN（a,b） vo##a##b（）

那麼FUN（id ma,in）會被替換成void main（）

5、 多行宏定義：

#define doit（m,n） for（int i=0;i<（n）；++i）\

{\

m+=i;\

}

Ⅹ C語言中宏替換占不佔用運行時間

宏替換，發生在預編譯的時候，預編譯後才能編譯運行，在運行的時候，宏替換已經完成，故不會佔用運行時間