c語言預定義宏
Ⅰ c語言中什麼是宏定義，它是干什麼的
就是強制性的字元替換，比如說你要用a代表6，那麼後面所有是a的地方都是用字元6替換掉就可以了，這個是不進行運算只是替換
比如define a (a+b)
那麼後面所有a的地方都可以全部替換成（a+b）但是你不能用a+b的結果
Ⅱ c語言宏定義如何用用宏定義有什麼優點
用#define 來定義，如#define Max 100
優點：在以後的程序中 要修改Max的大小 不用跑到程序中找 直接修改
#define Max 的大小即可。很方便。
Ⅲ C語言中的#define是什麼意思，有什麼作用，怎樣用
#define 定義一個標識符來表示一個常量。
其特點是定義的標識符不佔內存，只是一個臨時的符號，預編譯後這個符號就不存在了。
用 #define 定義標識符的一般形式為：
#define 標識符 常量 //注意, 最後沒有分號
#define 和 #include 一樣，也是以「#」開頭的。凡是以「#」開頭的均為預處理指令，#define也不例外。
(3)c語言預定義宏擴展閱讀：
宏定義 #define 一般都寫在函數外面，與 #include 寫在一起。當然，寫在函數裡面也沒有語法錯誤，但通常不那麼寫。#define 的作用域為自 #define 那一行起到源程序結束。如果要終止其作用域可以使用 #undef 命令。
使用宏定義可以用宏代替一個在程序中經常使用的常量。注意，是「經常」使用的。這樣，當需要改變這個常量的值時，就不需要對整個程序一個一個進行修改，只需修改宏定義中的常量即可。
且當常量比較長時，使用宏就可以用較短的有意義的標識符來代替它，這樣編程的時候就會更方便，不容易出錯。因此，宏定義的優點就是方便和易於維護。
Ⅳ C語言中#define是什麼意思
是定義的意思，將一個變數強制定義為你想要的值。如#define PI 3.14就是將PI的值定義成3.14，這樣在程序里看到PI就可以替換成3.14了。
Ⅳ C語言中的宏定義怎麼用
C語言中的宏定義用法分為兩種。
1、不帶參數的宏定義比較簡單，就是用一個指定的標識符來代表一個字元串。它的一般形式為「#define 標識符 字元串」，例如#define E 2.718281828459。這種方法使用戶能以一個簡單的名字代替一個長的字元串。
2、帶參數的宏定義不是僅僅進行簡單的字元串替換，還要進行參數替換。其定義的一般形式為；「#define 標識符（宏名）（參數表） 字元串」，字元串中包含在括弧中所指定的參數。例如#define S（a，b） a*b area=S（3. 2)。
(5)c語言預定義宏擴展閱讀：
宏定義只佔編譯時間，函數調用則佔用運行時間（分配單元，保存現場，值傳遞，返回），每次執行都要載入，所以執行相對宏定義會較慢。
使用宏定義次數多時，宏定義展開後源程序很長，因為每展開一次都使程序增長，但是執行起來比較快一點（這也不是絕對的，當有很多宏定義展開，目標文件很大，執行的時候運行時系統換頁頻繁，效率就會低下）。而函數調用不使源程序變長。
Ⅵ 宏定義c語言是什麼意思
在C語言源程序中，允許用一個標識符來表示一個字元串，稱為宏，宏定義是由源程序中的宏定義命令完成的，宏替換是由預處理程序自動完成的。宏定義是C提供的三種預處理功能的其中一種，這三種預處理包括：宏定義、文件包含、條件編譯。
C語言中，預處理過程讀入源代碼，檢查包含預處理指令的語句和宏定義，並對源代碼進行相應的轉換，預處理過程還會刪除程序中的注釋和多餘的空白符號。
預處理指令是以#開頭的代碼行，#必須是該行除了空白字元外的第一個字元。#後是指令關鍵字，在#和指令關鍵字之間允許存在若干空白字元。
宏的用途
在於自動化頻繁使用的序列或者是獲得一種更強大的抽象能力。
計算機語言如C語言或匯編語言有簡單的宏系統，由編譯器或匯編器的預處理器實現。C語言的宏預處理器的工作只是簡單的文本搜索和替換，使用附加的文本處理語言如M4，C程序員可以獲得更精巧的宏。
Lisp類語言如Common Lisp和Scheme有更精巧的宏系統：宏的行為如同是函數對自身程序文本的變形，並且可以應用全部語言來表達這種變形。一個C宏可以定義一段語法的替換，然而一個Lisp的宏卻可以控制一節代碼的計算。
以上內容參考：網路-宏定義
Ⅶ c語言 define 怎麼用的
C語言中define的用法(2009-08-17 19:21:11)轉載標簽： 雜談
define是C語言中的預處理命令，它用於宏定義，可以提高源代碼的可讀性，為編程提供方便。
預處理命令以「#」號開頭，如包含命令#include，宏定義命令#define等。一般都放在源文件的前面，它們稱為預處理部分。
所謂預處理是指在進行編譯之前所作的工作。預處理是C語言的一個重要功能，它由預處理程序負責完成。當對一個源文件進行編譯時，系統將自動引用預處理程序對源程序中的預處理部分作處理，處理完畢自動進入對源程序的編譯。
宏的定義
在C或C++語言源程序中允許用一個標識符來表示一個字元串，稱為「宏」。被定義為「宏」的標識符稱為「宏名」。在編譯預處理時，對程序中所有出現的「宏名」，都用宏定義中的字元串去代換，這稱為「宏代換」或「宏展開」。宏定義是由源程序中的宏定義命令完成的。宏代換是由預處理程序自動完成的。
在C或C++語言中，「宏」分為有參數和無參數兩種。
無參數宏定義
無參數宏就是不帶參數，其定義的一般形式為：
#define 標識符 字元串
「標識符」為所定義的宏名。「字元串」可以是常數、表達式、格式串等。
例如：
#define PI 3.14
它的作用是指定標識符PI來代替常數3.14。在編寫源程序時，所有用到3.14的地方都可用PI代替，而對源程序作編譯時，將先由預處理程序進行宏代換，即用3.14去置換所有的宏名PI，然後再進行編譯。
宏定義是用宏名來表示一個字元串，在宏展開時又以該字元串取代宏名，這只是一種簡單的代換，字元串可以是常數，也可以是表達式，預處理程序對它不作任何檢查。如有錯誤，只能在編譯已被宏展開後的源程序時發現。
宏定義不是說明或語句(它是預處理指令)，在行末不必加分號，如加上分號則連分號也一起置換。
下面舉一個無參數宏替代常數的例子：
#define PI 3.14
#include <stdio.h>
int main()
{
float r = 1.0;
float area = PI*r*r;
printf("The area of the circle is %f",area);
return 0;
}
再舉一個使用無參數宏替代字元串的例子：
#define M (y*y+3*y)
#include <stdio.h>
int main()
{
int s,y;
printf("input a number: ");
scanf("%d",&y);
s = 3*M + 4*M + 5*M;
printf("s=%d\n",s);
return 0;
}
# define M (y*y+3*y) 定義M表達式(y*y+3*y)。在編寫源程序時，所有的(y*y+3*y)都可由M代替，而對源程序作編譯時，將先由預處理程序進行宏代換，即用 (y*y+3*y)表達式去置換所有的宏名M，然後再進行編譯。
上常式序中首先進行宏定義，定義M表達式(y*y+3*y),在s= 3*M+4*M+5* M中作了宏調用。在預處理時經宏展開後該語句變為：s=3*(y*y+3*y)+4* (y*y+3*y)+5* (y*y+3*y);但要注意的是，在宏定義中表達式(y*y+3*y)兩邊的括弧不能少。否則會發生錯誤。
帶參數宏定義
C語言允許宏帶有參數。在宏定義中的參數稱為形式參數，在宏調用中的參數稱為實際參數。對帶參數的宏，在調用中，不僅要宏展開，而且要用實參去代換形參。
帶參數宏定義的一般形式為：
#define 宏名(形參表) 字元串
在字元串中含有各個形參。
帶參數宏調用的一般形式為：
宏名(實參表)
例如：
#define M(y) y*y+3*y
....
k=M(5);
....
在宏調用時，用實參5去代替形參y，經預處理宏展開後的語句為:
k=5*5+3*5
舉一個具體例子：
#define MAX(a,b) (a>b)?a:b
#include <stdio.h>
int main()
{
int x,y,max;
printf("input two numbers: ");
scanf("%d%d",&x,&y);
max = MAX(x,y);
printf("max=%d\n",max);
return 0;
}
上常式序的第一行進行帶參數宏定義，用宏名MAX表示條件表達式(a>b)?a:b，形參a,b均出現在條件表達式中。程序第七行max = MAX(x, y)為宏調用，實參x,y，將代換形參a,b。宏展開後該語句為： max = (x>y)?x:y;用於計算x,y中的大數。
對於帶參的宏定義有以下問題需要說明：
1. 帶參宏定義中，宏名和形參表之間不能有空格出現。
例如把： #define MAX(a,b) (a>b)?a:b寫為： #define MAX (a,b) (a>b)?a:b 將被認為是無參宏定義，宏名MAX代表字元串 (a,b)(a>b)?a:b。
宏展開時，宏調用語句： max = MAX(x,y);將變為： max = (a,b)(a>b)?a:b(x,y);這顯然是錯誤的。
2. 在宏定義中的形參是標識符，而宏調用中的實參可以是表達式。
#define SQ(y) (y)*(y)
#include <stdio.h>
int main()
{
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
return 0;
}
上例中第一行為宏定義，形參為y。程序第七行宏調用中實參為a+1，是一個表達式，在宏展開時，用a+1代換y，再用(y)*(y) 代換SQ，得到如下語句： sq=(a+1)*(a+1); 這與函數的調用是不同的，函數調用時要把實參表達式的值求出來再賦予形參。而宏代換中對實參表達式不作計算直接地照原樣代換。
3. 在宏定義中，字元串內的形參通常要用括弧括起來以避免出錯。在上例中的宏定義中(y)*(y)表達式的y都用括弧括起來，結果是正確的。如果去掉括弧，把程序改為以下形式：
#define SQ(y) y*y
#include <stdio.h>
int main()
{
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
return 0;
}
運行結果為：input a number:3
sq=7 （我們期望的結果卻是16）。
問題在哪裡呢? 這是由於代換只作符號代換而不作其它處理而造成的。 宏代換後將得到以下語句： sq=a+1*a+1; 由於a為3故sq的值為7。這顯然與題意相違，因此參數兩邊的括弧是不能少的。有時候，即使在參數兩邊加括弧還是不夠的，請看下面程序：
#define SQ(y) (y)*(y)
#include <stdio.h>
int main()
{
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=160/SQ(a+1);
printf("sq=%d\n",sq);
return 0;
}
本程序與前例相比，只把宏調用語句改為： sq=160/SQ(a+1); 運行本程序如輸入值仍為3時，希望結果為10。但實際運行的結果如下：input a number:3sq=160。
為什麼會得這樣的結果呢?分析宏調用語句，在宏代換之後變為： sq=160/(a+1)*(a+1);a為3時，由於「/」和「*」運算符優先順序和結合性相同，則先作160/(3+1)得40，再作40*(3+1)最後得160。為了得到正確答案應在宏定義中的整個字元串外加括弧，程序修改如下：
#define SQ(y) ((y)*(y))
#include <stdio.h>
int main()
{
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=160/SQ(a+1);
printf("sq=%d\n",sq);
return 0;
}
以上討論說明，對於宏定義，保險的做法是不僅應在參數兩側加括弧，也應在整個字元串外加括弧。
4. 帶參數的宏和帶參函數很相似，但有本質上的不同，把同一表達式用函數處理與用宏處理兩者的結果有可能是不同的。
下面舉一個例子進行對比：
使用函數：
#include <stdio.h>
int SQ(int);
int main()
{
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
return 0;
}
int SQ(int y)
{
return((y)*(y));
}
使用宏：
#define SQ(y) ((y)*(y))
#include <stdio.h>
int main()
{
int i=1;
while(i<=5)
printf("%d\n",SQ(i++));
return 0;
}
在使用函數的例子中函數名為SQ，形參為Y，函數體表達式為((y)*(y))。在使用宏的例子中宏名為SQ，形參也為y，字元串表達式為(y)*(y))。兩例表面是相同的，函數調用為SQ(i++)，宏調用為SQ(i++)，實參也是相同的。但輸出結果卻大不相同，分析如下：
在使用函數的例子中，函數調用是把實參i值傳給形參y後自增1。然後輸出函數值。因而要循環5次。輸出1～5的平方值。而在使用宏的例子中，宏調用時，只作代換。SQ(i++)被代換為((i++)*(i++))。在第一次循環時，由於i等於1，其計算過程為：表達式中前一個i初值為1，然後i自增1變為2，因此表達式中第2個i初值為2，兩相乘的結果也為2，然後i值再自增1，得3。在第二次循環時，i值已有初值為3，因此表達式中前一個i為3，後一個i為4，乘積為12，然後i再自增1變為5。進入第三次循環，由於i 值已為5，所以這將是最後一次循環。計算表達式的值為5*6等於30。i值再自增1變為6，不再滿足循環條件，停止循環。從以上分析可以看出函數調用和宏調用二者在形式上相似，在本質上是完全不同的。
"\","#","#@"和"##"
在用#define 定義時 , 斜杠("\")是用來續行的，"#"用來把參數轉換成字元串，是給參數加上雙引號。"##"則用來連接前後兩個參數，把它們變成一個字元串,"#@"是給參數加上單引號。下面的例子會使您很容易理解。
#define Conn(x,y) x##y
#define ToChar(a) #@a
#define ToString(x) #x
int n = Conn(123,456); 結果就是n=123456;
char* str = Conn("asdf", "adf")結果就是 str = "asdfadf";
char a = ToChar(1);結果就是a='1';
char* str = ToString(123132);就成了str="123132";
為什麼需要」#」,」 #@」和」##」這三個操作符呢？原因如下：
宏名在源程序中若用引號括起來，則預處理程序不對其作宏代換。如下：
#define OK 100
#include <stdio.h>
int main()
{
printf("OK");
printf("\n");
return 0;
}
上例中定義宏名OK表示100，但在printf語句中OK被引號括起來，因此不作宏代換。程序的運行結果為：OK,這表示把「OK」當字元串處理。
同樣，宏名在源程序中若用單引號括起來，則預處理程序也不對其作宏代換。
宏定義的嵌套
宏定義允許嵌套，在宏定義的字元串中可以使用已經定義的宏名。在宏展開時由預處理程序層層代換。例如：
#define PI 3.1415926
#define S PI*y*y
對語句： printf("%f",s);
在宏代換後變為： printf("%f",3.1415926*y*y);
結束語
使用宏代替一個在程序中經常使用的常量，這樣該常量改變時，不用對整個程序進行修改，只修改宏定義的字元串即可，而且當常量比較長時，我們可以用較短的有意義的標識符來寫程序，這樣更方便一些。舉一個大家比較熟悉的例子，圓周率π是在數學上常用的一個值，有時我們會用3.14來表示，有時也會用3.1415926等，這要看計算所需要的精度，如果我們編制的一個程序中要多次使用它，那麼需要確定一個數值，在本次運行中不改變，但也許後來發現程序所表現的精度有變化，需要改變它的值，這就需要修改程序中所有的相關數值，這會給我們帶來一定的不便，但如果使用宏定義，使用一個標識符來代替，則在修改時只修改宏定義即可，還可以減少輸入 3.1415926這樣長的數值多次的情況，我們可以如此定義 #define pi 3.1415926，既減少了輸入又便於修改，何樂而不為呢？
另外，使用帶參數的宏定義可完成函數調用的功能，又能減少系統開銷，提高運行效率。正如C語言中所講，函數的使用可以使程序更加模塊化，便於組織，而且可重復利用，但在發生函數調用時，需要保留調用函數的現場，以便子函數執行結束後能返回繼續執行，同樣在子函數執行完後要恢復調用函數的現場，這都需要一定的時間，如果子函數執行的操作比較多，這種轉換時間開銷可以忽略，但如果子函數完成的功能比較少，甚至於只完成一點操作，如一個乘法語句的操作，則這部分轉換開銷就相對較大了，但使用帶參數的宏定義就不會出現這個問題，因為它是在預處理階段即進行了宏展開，在執行時不需要轉換，即在當地執行。宏定義可完成簡單的操作，但復雜的操作還是要由函數調用來完成，而且宏定義所佔用的目標代碼空間相對較大。所以在使用時要依據具體情況來決定是否使用宏定義。
Ⅷ 在C語言中 宏定義是什麼
在C語言源程序中，允許用一個標識符來表示一個字元串，稱為宏，宏定義是由源程序中的宏定義命令完成的，宏替換是由預處理程序自動完成的。宏定義是C提供的三種預處理功能的其中一種，這三種預處理包括：宏定義、文件包含、條件編譯。
(8)c語言預定義宏擴展閱讀：
宏（Macro），是一種批量處理的稱謂。計算機科學里的宏是一種抽象，它根據一系列預定義的規則替換一定的文本模式。
計算機語言如C語言或匯編語言有簡單的宏系統，由編譯器或匯編器的預處理器實現。C語言的宏預處理器的工作只是簡單的文本搜索和替換，使用附加的文本處理語言如M4，C程序員可以獲得更精巧的宏。
Ⅸ C語言，#define語句的用法。
1.簡單的宏定義
格式：#define 標識符 替換列表
說明：替換列表可以是數，字元串字面量，標點符號，運算符，標識符，關鍵字，字元常量。
注意：替換列表是可以為空的
典型錯誤：
#defineN=100
inta[N];/*這樣會成為inta[=100],這里會處理成為一種標識記號一樣*/
#defineN100;
inta[N];/*帶分號的定義會成為inta[100;],這是一種很常見的錯誤*/
#definepin(int*);
pina,b;
int*a,b;/*本意是a和b都是int型指針，但是實際上變成int*a,b;a是int型指針，而b是int型變數。這是應該使用typedef來代替define，這樣a和b就都是int型指針了。*/
典型的使用方法：
使用宏定義可以自己根據自己的習慣來定義甚至改變C語言的語法習慣，例如：
#defineBEGIN{
#defineEND}
intmain()BEGIN
printf("DEFINE----
");
END定義一個循環
#defineLOOPfor(;;)
重新定義數據類型
#defineITint
2.帶參數的宏
#define 標識符（x1,x2,x3...xn） 替換列表 （注意：x1,x2,x3..是宏的參數，標識符和其左括弧之間不能有空格）
使用方法：
#defineMAX(x,y)((x)>(y)?(x):(y))
i=MAX(j+k,m-n);
替換為：
i=MAX((j+k)>(m-n)?(j+k):(m-n));
#defineSI_EX(n)((n)%2==0)
if(SI_EX(i))i++;
替換為：
if(SI_EX((i)%2==0))
通過以上例子可以看出，標識符帶參數（X1，X2，X3.....）在替換時會被替換列表（Y1，Y2，Y3....）對應的替換，但是和順序無關。
3.宏的特殊單行定義
#defineA(x)T_##x
#defineB（x)#@x
#defineC（x)#x
x=1
替換為：
A(1)------> T_1 （T_##x,##符號是記號粘黏符號，將前後的字元粘黏起來。）
B(1)------> '1' （ #@x , #@ 符號會將宏的參數進行字元串字面量化，並且加『』號）
C(1)------> "1" （ #x ,#符號會將宏的參數進行字元串字面量化，並且加""號）
4.define的多行定義
define可以替代多行的代碼，在每一個換行的時候加上一個""
#defineMAX(X,Y)do{
語句1;
語句2;
/*注釋的寫法*/
}while(0)/*(notrailing;)*/5.在大規模的開發過程中，特別是跨平台和系統的軟體里，define最重要的功能是條件編譯。
#ifdefWINDOWS
......
......
#endif
#ifdefLINUX
......
......
#endif
可以在編譯的時候通過#define設置編譯環境
6.取消宏
#undef標識符
7.條件編譯
#ifdefXXX…(#else)…#endif
8.預定義宏
在C語言中收錄了一些有用的宏，這些宏是提供當前編譯信息的。
__LINE__ 被編譯文件的行數
（整型）
__FILE__ 被編譯文件的名字 （字元型）
__DATE__ 編譯日期 （字元型）
__TIME__ 編譯時間 （字元型）
__STDC__ 如果編譯器接受標准C，那麼值為1. （整型）
通常在編譯的時候可以用這些預定義的宏來進行排錯，例如：
一般情況下，當出現除零的情況時編譯器是沒有提示的，可以自定義一個解決辦法。
#defineCHECKZERO(divisor)
if(divisor==0)
printf("***ATTEMPTTODIVIDEBYZEROINLINE%doffile%s*** ",__LINE__,__FILE__);
引用方法
CHECKZERO(j);
k=i/j;