編譯過程簡介：

?預編譯：gcc -E file.c -o file.i

處理注釋，以空格代替

將宏定義展開

處理條件編譯指令

處理#include，展開被包含的文件

保留編譯器需要使用的#pragma指令

編譯： gcc -S file.i -o file.s

對預處理文件進行詞法分析，語法 分析，語義分析

匯編：gcc -c file.s -o hello.o

將匯編代碼翻譯成機器碼

鏈接：

將各個模塊之間的相互引用的部分處理好，使得各個模塊之間能夠正確的銜接。將各個獨立的模塊鏈接成可執行的程序

靜態鏈接：各個模塊簡單連接，編譯期完成

動態鏈接：共享庫文件，運行期完成

?

定義宏常量：

#define定義宏常量，可以出現咋代碼的任何地方；從定義行開始，之后的代碼都可使用這個宏常量（不管是否在某個函數中定義）

定義宏表達式：

1 #include <stdio.h> 2 int f1(int a, int b) 3 { 4 #define _MIN_(a,b) ((a)<(b) ? a : b) 5 return _MIN_(a, b); 6 } 7 int f2(int a, int b, int c) 8 { 9 return _MIN_(_MIN_(a,b), c); 10 } 11 int main() 12 { 13 printf("%d\n", f1(2, 1)); 14 printf("%d\n", f2(5, 3, 2)); 15 return 0; 16 }

宏表達式的域：自定義行開始之后的所有代碼都可以使用

定義宏只能在一行中完成，（使用接續符換行）

宏表達式與函數的對比：
宏表達式在預編譯的過程中被處理，編譯器不知道宏表達式的存在；宏表達式用實參 完全代替形參，不進行任何運算；宏表達式沒有任何的調用開銷；宏表達式不能出現遞歸定義。

#define func(n) ((n>0) ? func(n-1) : 0 ); //錯誤，遞歸定義宏

#undef:用于結束宏的作用域

條件編譯的使用：

條件編譯是預編譯指示命令，用于控制是否編譯某段代碼；執行行為類似：if else語句。

1 #if (exp1) 2 ....; 3 #else 4 ...; 5 #endif

#include：
本質：將已經存在的文件內容，復制到當前文件中。（預編譯中完成）

1 // global.h 2 int global = 10; 3 4 // test.h 5 #include <stdio.h> 6 #include "global.h" 7 8 const char* NAME = "Hello world!"; 9 10 void f() 11 { 12 printf("Hello world!\n"); 13 } 14 15 // test.c 16 #include <stdio.h> 17 #include "test.h" 18 #include "global.h" 19 20 int main() 21 { 22 f(); 23 24 printf("%s\n", NAME); 25 26 return 0; 27 }

編譯test.c時，由于global.h同時在test.h中包含了，又在test.c中包含了，這樣int global = 10;就在test.c中重復了兩次，定義了兩次，提示出錯。

1 // global.h 2 #ifndef _GLOBAL_H_ 3 #define _GLOBAL_H_ 4 int global = 10; 5 #endif 6 7 // test.h 8 #ifndef _TEST_H_ 9 #define _TEST_H_ 10 #include <stdio.h> 11 #include "global.h" 12 const char* NAME = "Hello world!"; 13 void f() 14 { 15 printf("Hello world!\n"); 16 } 17 #endif 18 19 // test.c 20 #include <stdio.h> 21 #include "test.h" 22 #include "global.h" 23 24 int main() 25 { 26 f(); 27 printf("%s\n", NAME); 28 return 0; 29 }

使用條件編譯，可以保證前面包含進來的（復制進來）內容，不再重復復制，而不管你寫了多個頭包含語句。

#error和#line：

#error用于生成一個編譯錯誤信息，并停止編譯

#error message? //message不需要使用雙引號包圍，message是程序員自定義的信息

#warring 用于生成警告，但不停止編譯

1 #include <stdio.h> 2 #define CONST_NAME1 "CONST_NAME1" 3 #define CONST_NAME2 "CONST_NAME2" 4 int main() 5 { 6 #ifndef COMMAND 7 #warning Compilation will be stoped ... 8 #error No defined Constant Symbol COMMAND 9 #endif 10 printf("%s\n", COMMAND); 11 printf("%s\n", CONST_NAME1); 12 printf("%s\n", CONST_NAME2); 13 return 0; 14 }

#line用于強制指定新的行號和編譯文件名，并對源程序的代碼重新編號
本質：是重定義_LINE_和_FINE_(內部宏定義)

用法：#line number filename

1 #include <stdio.h> 2 #line 14 "Hello.c" //__LINE__=14,即下一行行號為14;__FILE__="Hello.c" 3 #define CONST_NAME1 "CONST_NAME1" 4 #define CONST_NAME2 "CONST_NAME2" 5 void f() 6 { 7 return 0; // 該行行號為20，提示出錯 8 } 9 int main() 10 { 11 printf("%s\n", CONST_NAME1); 12 printf("%s\n", CONST_NAME2); 13 printf("%d\n", __LINE__); //27 14 printf("%s\n", __FILE__); //hello.c 15 f(); 16 return 0; 17 }

#pragma:

#pragma是編譯器指示字，用于指示編譯器完成一些特定的動作；它所定義的很多指示字是編譯器和操作系統特有的；在不同的編譯器間不可移植。

預處理器將忽略它不認識的#pragma指令

兩個不同的編譯器可能以兩種不同的方式解釋同一條#pragma指令

#pragma message

?

#和##號運算符：

#用于在預編譯期將宏參數轉換為字符串，注意：是在預編譯期完成

1 #include <stdio.h> 2 #define CONVERS(x) #x //#用于將CONVERS(x)中的x轉換為x字符串 3 int main() 4 { 5 printf("%s\n", CONVERS(Hello world!)); //Hello world! 6 printf("%s\n", CONVERS(100)); //100 7 printf("%s\n", CONVERS(while)); //while 8 printf("%s\n", CONVERS(return)); //return 9 return 0; 10 } 1 #include <stdio.h> 2 #define CALL(f, p) (printf("Call function %s\n", #f), f(p)) 3 int square(int n) 4 { 5 return n * n; 6 } 7 8 int f(int x) 9 { 10 return x; 11 } 12 13 int main() 14 { 15 printf("1. %d\n", CALL(square, 4)); 16 // Call function square 17 //1.16 18 printf("2. %d\n", CALL(f, 10)); 19 //Call function f 20 //2.10 21 return 0; 22 }

##用于在編譯期粘連兩個符號：

1 #include <stdio.h> 2 #define NAME(n) name##n 3 int main() 4 { 5 int NAME(1); 6 int NAME(2); 7 NAME(1) = 1; 8 NAME(2) = 2; 9 printf("%d\n", NAME(1)); //1 10 printf("%d\n", NAME(2)); //2 11 return 0; 12 }

?

轉載于:https://www.cnblogs.com/data1213/p/4821896.html

總結

以上是生活随笔為你收集整理的编译过程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。