1樓：匿名使用者
c/c++中的巨集定義是進行符號常量定義，該定義用於定義一種符號資訊用來表示一些特殊的資訊，使源**更具有可讀性，同時，也可以提高系統的可移植性。巨集定義是在編譯時進行解釋與替換的，實際執行中的**是沒有巨集定義符號的。而一般變數或常量的定義在系統執行中，是有自己的記憶體空間，訪問許可權，和生存週期的。
巨集定義常量
#define pi 3.141
注意：1、符號常量與數值間沒有等號 2、該語句不需要以分號結尾
如：#define pi = 3.141 語法上無大問題，但應用中可能會出錯，編譯時，所有的pi會替換成『= 3.141'
#define pi 3.141 ; 語法上無大問題，但應用中可能會出錯，編譯時，所有的pi會替換成『3.141 ;』
變數定義
double pi=3.141 ; //定義乙個變數pi，在記憶體中會給變數pi分配乙個空間，其空間中儲存了3.141，在使用中，可以隨時改變pi值，如：
pi=3.1415926;
常量定義
const pi=3.141 ; //因為沒有寫型別，預設為int型別，所以，這裡的pi值實際為3
const double pi=3.141 ; //正確定義乙個浮點型常量
常量與變數的差別是：常量一經定義後，就不能再修改！如果在使用中修改pi，則編譯或執行時會出錯，如vc6報錯：
error c2166: l-value specifies const object
常量與巨集定義常量的區別是： 巨集定義會在預處理階段將用define定義的內容對**中相應的識別符號進行替換（編譯期替換，編譯後巨集消失）。因此程式執行時，常量表中並沒有用define定義的常量，系統不為它分配記憶體。
const定義的常量，在程式執行時在常量表中，系統為它分配記憶體。
2樓：
要說區別其實也沒有什麼，主要都是為了使用方便，巨集定義的是乙個常量，一般定義可以是常亮也可以是變數，另外一般的巨集定義是全域性的，可以任意引用，一般的定義有一定的作用域
3樓：文靜婷留
#define pi=3.141 →在編譯的時候替換 double pi=3.141→變數，可以重新賦值
這兩種,當多次用到pi時用巨集定義也就是#define pi=3.141
const double pi=3.141; //常值變數，不可以重新賦值
4樓：
#define pi=3.141 //在編譯的時候替換
//下面是在執行的時候分配單元
double pi=3.141; //變數，可以重新賦值const double pi=3.141; //常值變數，不可以重新賦值
5樓：蘋果砸向牛頓
#define pi=3.141 //在編譯的時候替換
//下面是執行時分配單元
double pi=3.141 //變數 可以重新賦值
const double pi=3.141 //常值變數 不可以重新賦值
簡單說就是double可重新賦值，而const不可重新賦值
6樓：
生存域和分配空間的區別。
#define 定義，巨集會從當前生效，一直到當前檔案結束。
且變編譯時會進行巨集擴充套件 遇到pi 會自動被編譯器替換為3.141,不會分配空間
double 和const定義遵循一般的變數生存域原則。即從當前開始到下個" }".
void test()
//k的生存域到此結束
..............................
}double 會為變數分配空間，const 會將常量分配到全域性資料區。
由於define定義沒有空間，即不能將巨集的指標賦值給變數或常量。
編譯時替換，因為將源**翻譯成可執行的檔案時，要經過編譯和鏈結，才能生成可執行檔案(exe),也就是在這個過程中編譯器直接將巨集擴充套件成定義的內容
c++ 中define（巨集定義） 各種用法（含特殊），小舉個例子，謝謝！
7樓：會飛的小兔子
1、define是巨集定義，程式在預處理階段將用define定義的內容進行了替換。因此在程式執行時，常量表中並沒有用define定義的常量，系統不為它分配記憶體。而const定義的常量，在程式執行時，存在常量表中，且系統為它分配記憶體。
2、define定義的常量，預處理時只是直接進行了替換，因此在編譯時不能進行資料型別檢驗。而const定義的常量，在編譯時進行嚴格的型別檢驗，可以避免出錯。
3、define定義表示式時要注意「邊緣效應」。
例如：#definen1+2；
floata=n/2.0;
按照常規做法，可能會認為結果是3/2=1.5；
但是實際上，結果應該為1+2/2.0=2.0；
若想要實現3/2，則#definen(1+2)；
即為避免邊緣效應，一定要加括號。
擴充套件資料c++巨集定義
#define命令是c++語言中的乙個巨集定義命令，它用來將乙個識別符號定義為乙個字串，該識別符號被稱為巨集名，被定義的字串稱為替換文字。
1、簡單的巨集定義：
#define 《巨集名》 《字串》
例： #define pi 3.14159262、帶引數的巨集定義
#define 《巨集名》 (《參數列》) 《巨集體》
例： #define a(x) x
8樓：湖人總冠軍
1、define是巨集定義，在預處理階段，程式將替換define定義的內容，因此，當程式執行時，常量表中沒有用define定義的常量，系統不會為它分配記憶體，當程式執行時，const定義的常量存在於常量表中，並且系統為它分配記憶體。
2、define定義的常量，只在預處理期間直接替換，因此在編譯期間無法執行資料型別驗證，對於const定義的常量，在編譯時進行嚴格的型別檢查可以避免錯誤。
3、define定義表示式時要注意「邊緣效應」。
例如：#definen1+2；
floata=n/2.0;
按慣例，可認為結果為3/2=1.5；
但實際上，結果應該是1+2/2.0=2.0；
如果你想達到3/2，定義（1+2）；
為了避免邊緣效應，必須加括號。
9樓：匿名使用者
1 無參巨集定義
無參巨集的巨集名後不帶引數。
其定義的一般形式為：
#define 識別符號 字串
其中的「#」表示這是一條預處理命令。凡是以「#」開頭的均為預處理命令。「define」為巨集定義命令。「識別符號」為所定義的巨集名。「字串」可以是常數、表示式、格式串等。
在前面介紹過的符號常量的定義就是一種無參巨集定義。此外，常對程式中反覆使用的表示式進行巨集定義。
例如：#define m (y*y+3*y)
它的作用是指定識別符號m來代替表示式(y*y+3*y)。在編寫源程式時，所有的(y*y+3*y)都可由m代替，而對源程式作編譯時，將先由預處理程式進行巨集代換，即用(y*y+3*y)表示式去置換所有的巨集名m，然後再進行編譯。
【例】#define m (y*y+3*y)
main()
上例程式中首先進行巨集定義，定義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)兩邊的括號不能少。否則會發生錯誤。如當作以下定義後：
#difine m y*y+3*y
在巨集時將得到下述語句：
s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y；
這相當於：
3y2+3y+4y2+3y+5y2+3y；
顯然與原題意要求不符。計算結果當然是錯誤的。因此在作巨集定義時必須十分注意。應保證在巨集代換之後不發生錯誤。
對於巨集定義還要說明以下幾點：
1) 巨集定義是用巨集名來表示乙個字串，在巨集時又以該字串取代巨集名，這只是一種簡單的代換，字串中可以含任何字元，可以是常數，也可以是表示式，預處理程式對它不作任何檢查。如有錯誤，只能在編譯已被巨集後的源程式時發現。
2) 巨集定義不是說明或語句，在行末不必加分號，如加上分號則連分號也一起置換。
3) 巨集定義必須寫在函式之外，其作用域為巨集定義命令起到源程式結束。如要終止其作用域可使用# undef命令。
例如：#define pi 3.14159
main()
#undef pi
f1()
表示pi只在main函式中有效，在f1中無效。
4) 巨集名在源程式中若用引號括起來，則預處理程式不對其作巨集代換。
【例】#define ok 100
main()
上例中定義巨集名ok表示100，但在printf語句中ok被引號括起來，因此不作巨集代換。程式的執行結果為：ok這表示把「ok」當字串處理。
5) 巨集定義允許巢狀，在巨集定義的字串中可以使用已經定義的巨集名。在巨集時由預處理程式層層代換。
例如：#define pi 3.1415926
#define s pi*y*y /* pi是已定義的巨集名*/
對語句：
printf("%f",s);
在巨集代換後變為：
printf("%f",3.1415926*y*y);
6) 習慣上巨集名用大寫字母表示，以便於與變數區別。但也允許用小寫字母。
7) 可用巨集定義表示資料型別，使書寫方便。
例如：#define stu struct stu
在程式中可用stu作變數說明：
stu body[5],*p;
#define integer int
在程式中即可用integer作整型變數說明：
integer a,b;
應注意用巨集定義表示資料型別和用typedef定義資料說明符的區別。
巨集定義只是簡單的字串代換，是在預處理完成的，而typedef是在編譯時處理的，它不是作簡單的代換，而是對型別說明符重新命名。被命名的識別符號具有型別定義說明的功能。
請看下面的例子：
#define pin1 int *
typedef (int *) pin2;
從形式上看這兩者相似， 但在實際使用中卻不相同。
下面用pin1，pin2說明變數時就可以看出它們的區別：
pin1 a,b;在巨集代換後變成:
int *a,b;
表示a是指向整型的指標變數，而b是整型變數。
然而：pin2 a,b;
表示a,b都是指向整型的指標變數。因為pin2是乙個型別說明符。由這個例子可見，巨集定義雖然也可表示資料型別， 但畢竟是作字元代換。在使用時要分外小心，以避出錯。
8) 對「輸出格式」作巨集定義，可以減少書寫麻煩。
【例】中就採用了這種方法。
#define p printf
#define d "%d\n"
#define f "%f\n"
main()
2 帶參巨集定義
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
main()
上例程式的第一行進行帶參巨集定義，用巨集名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. 在帶參巨集定義中，形式引數不分配記憶體單元，因此不必作型別定義。而巨集呼叫中的實參有具體的值。
要用它們去代換形參，因此必須作型別說明。這是與函式中的情況不同的。在函式中，形參和實參是兩個不同的量，各有自己的作用域，呼叫時要把實參值賦予形參，進行「值傳遞」。
而在帶參巨集中，只是符號代換，不存在值傳遞的問題。
3. 在巨集定義中的形參是識別符號，而巨集呼叫中的實參可以是表示式。
【例】#define sq(y) (y)*(y)
main()
上例中第一行為巨集定義，形參為y。程式第七行巨集呼叫中實參為a+1，是乙個表示式，在巨集時，用a+1代換y，再用(y)*(y) 代換sq，得到如下語句：
sq=(a+1)*(a+1);
這與函式的呼叫是不同的，函式呼叫時要把實參表示式的值求出來再賦予形參。而巨集代換中對實參表示式不作計算直接地照原樣代換。
4. 在巨集定義中，字串內的形參通常要用括號括起來以避免出錯。在上例中的巨集定義中(y)*(y)表示式的y都用括號括起來，因此結果是正確的。如果去掉括號，把程式改為以下形式：
【例】#define sq(y) y*y
main()
執行結果為：
input a number:3
sq=7
c語言巨集定義與函式的差別我覺得巨集定義和函式
來自海印寺芳香襲人 的啄木鳥 首先巨集定義和函式是有差別的 巨集定義是在編譯之前處理的，不做語法檢查。這個很危險另外我要說 define a b,c 表示bc之合，在結果上和函式確實一樣 但是當函式複雜的情況下，你就沒法代替了哦！ define a x,y x y?x y x y和int a x,y...
c語言中為什麼字面常量與巨集定義不佔記憶體空間
yesyes科 因為巨集在預處理階段就會被替換掉,到了編譯的階段是沒有巨集存在的,它自然到不了可執行檔案中,所以它不佔記憶體空間。字面常量,佔不佔空間要看情況。使用方式如下 1 首先新建乙個工程和.c檔案，輸入標頭檔案 主函式和巨集定義。2 然後定義變數型別。3 接著輸入引數的值。4 然後呼叫巨集。...
一般化學品的定義，一般化學品的定義請問如何區分危險化學品和一般化學品
化學品中具有易燃 易爆 有毒 有腐蝕性等特性，會對人 包括生物 裝置 環境造成傷害和侵害的化學品叫危險化學品。危險化學品在不同的場合，叫法或者說稱呼是不一樣的，如在生產 經營 使用場所統稱化工產品，一般不單稱危險化學品。在運輸過程中，包括鐵路運輸 公路運輸 水上運輸 航空運輸都稱為危險貨物。在儲存環...