0. 目錄

1.摘要
2.翻譯程序
2.1總述
2.2預處理
2.3編譯
2.4鏈接
3.執行程序
4.預處理指令
4.1 預定義符號
4.2 #define定義識別符號
4.3 #define定義宏
4.4 #：將宏的引數插入到字串中
4.5 ##：前處理器粘合劑
4.6 宏與函式的對比
4.7 命名約定
4.8 命令列定義
4.9 移除宏定義
4.10 條件編譯
4.11 檔案包含
4.12 #error
5.參考文獻

1. 摘要

本文將詳細介紹當你在VS中按下ctrl+f5或者linux命令列下輸入gcc 檔案名后計算機所執行的一系列操作，包括預處理、編譯、匯編、鏈接，以及一些C語言的預處理指令的使用，

2. 翻譯程序

2.1 總述

在ANSI C的任意一種實作中，存在2中不同的環境，第一種是翻譯環境，負責將源代碼轉換成可執行的機器指令；第二種是執行環境，用于實際執行代碼，[1]

一個程式從源代碼到可執行程式一共會經歷四個程序，分別是預處理、編譯、匯編、鏈接，每一步都承擔了不同的任務，

以下是GCC and Make Compiling, Linking and Building C/C++ Applications 中的描述 [2]：

GCC compiles a C/C++ program into executable in 4 steps as shown in the above diagram. For example, a “gcc -o hello.exe hello.c” is carried out as follows:

Pre-processing: via the GNU C Preprocessor (cpp.exe), which includes the headers (#include) and expands the macros (#define).

cpp hello.c > hello.i

The resultant intermediate file “hello.i” contains the expanded source code.

Compilation: The compiler compiles the pre-processed source code into assembly code for a specific processor.

gcc -S hello.i

The -S option specifies to produce assembly code, instead of object code. The resultant assembly file is “hello.s”.

Assembly: The assembler (as.exe) converts the assembly code into machine code in the object file “hello.o”.

as -o hello.o hello.s

Linker: Finally, the linker (ld.exe) links the object code with the library code to produce an executable file “hello.exe”.

ld -o hello.exe hello.o …libraries…

如圖一、二、三所示：

2.2 預處理

C預處理依賴C前處理器，C前處理器在程式執行之前查看程式（故稱為前處理器），根據程式中的預處理指令，前處理器把符號縮寫替換成其表示的內容，前處理器可以包含程式所需的其他檔案，可以選擇讓編譯器選擇性地查看某些代碼（如#if #endif等），

本質上而言，C前處理器是將一些文本轉換成了另外一些的文本，所以C前處理器并不能看懂C語言，

在預處理前，編譯器必須對該程式進行一些翻譯處理，
a）首先，編譯器把源代碼中出現的字符映射到源字符集，
b）第二，編譯器定位每個反斜杠 ‘\’ 后面跟著的換行符的實體，并洗掉他們，也就是說，將兩個物理行（physical line）：
printf("That is wond\
erful!\n");
轉化成一個邏輯行（logical line）：
printf("That is wonderful!\n");
注意，在這種場合下，換行符的概念是通過按下Enter鍵在源代碼檔案中換行所生成的字符，而不是指換行符 ‘\n’，
c）編譯器把文本劃分為預處理記號序列、空白序列和注釋序列，編譯器將用一個空格字符替換每一條注釋，如：
int /*It's an annotation*/ a;
變為
int a;

預處理指令將在下面一節詳細講解

那么現在，讓我們在Linux平臺下測驗一下當test.c源檔案只經過預處理后生成的test.i有何特點，

test.c檔案中，我們定義了識別符號X，宏MAX，如下：

#define MAX(X,Y) ((X)>(Y)?(X):(Y))
#define X 10
#include <stdio.h>
int main()
{
  int A = 20;
  int max = MAX(X,A);
  printf("max = %d\n",max);
  return 0;
}

只進行預處理

gcc -E test.c -o test.i

得到的test.i檔案如下

# 4 "test.c" 2
int main()
{
  int A = 20;
  int max = ((10)>(A)?(10):(A));
  printf("max = %d\n",max);
  return 0;
}

我們發現，在預處理階段，識別符號X與宏MAX所代表的一串字符被替換到了源檔案中的X與MAX處，
值得注意的是，#define定義的識別符號可以嵌套使用，例如上面的X作為了MAX的引數，

2.3 編譯

編譯的作用是將預處理完檔案中的源代碼轉化成匯編代碼

我們在Linux平臺下對 test.c 進行編譯操作，使test.c源檔案在編譯完之后停止

gcc -S test.c

得到的test.s檔案如下：

	.file	"test.c"
	.section	.rodata
.LC0:
	.string	"max = %d\n"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	$20, -4(%rbp)
	movl	$10, %eax
	cmpl	$10, -4(%rbp)
	cmovge	-4(%rbp), %eax
	movl	%eax, -8(%rbp)
	movl	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (GNU) 4.8.5 20150623 (Red Hat 4.8.5-44)"
	.section	.note.GNU-stack,"",@progbits

這其實就是 test.c 的匯編代碼，

2.4 鏈接

我們將匯編代碼檔案與庫函式檔案進行鏈接，隨即便能生成a.out的可執行檔案，

在Linux環境下，stdio.h頭檔案包括在 /usr/include 路徑下，

我們執行：

gcc-C test.c

得到

a.out

運行

./a.out

運行結果如圖四：

3. 執行程序

程式的執行程序如下：

1. 程式載入記憶體
2. 呼叫main函式
3. 開始執行代碼，開辟堆疊存放臨時變數與回傳地址，也可以使用靜態記憶體
4. 程式正常終止或意外終止

4. 預處理指令

4.1 預定義符號

C語言內置了一些預定義符號：

__FILE__ //進行編譯的源檔案
__LINE__ //檔案當前的行號
__DATE__ //檔案被編譯的日期 
__TIME__ //檔案被編譯的時間
__STDC__ //如果編譯器遵循ANSI C，其值為1，否則未定義

請看下面的代碼：

在這里插入代碼片
#include<stdio.h>
int main()
{
	printf("%s\n%d\n%s\n%s\n", __FILE__,__LINE__, __DATE__,__TIME__);
	return 0;
}

運行結果如圖五所示：

4.2 #define定義識別符號

#define能夠定義識別符號，在預處理階段前處理器會將識別符號的內容進行替換
如：

#define CH char
#define MAX 1000

4.3 #define定義宏

#define能夠定義宏，宏的宣告方式為

#define name(parament-list) stuff

其中，parament-list是一個由逗號隔開的引數串列，里面的引數能夠出現在stuff中，

注意，引數串列的左括號必須與name緊鄰，如果兩者之間有任何空白存在，引數串列就會被解釋成stuff的一部分，

如：

#define MAX(X,Y) ((X)>(Y)?(X):(Y))

這個宏用來求兩數之間的較大者

以下還有3條注意事項

1. 我們在定義宏的時候，最好把每一個引數用()括起來，最后，把整個stuff用()括起來
2. 宏的引數中可以出現其他#define定義的識別符號，但是宏不能遞回
3. 當前處理器搜索#define定義的符號時，字串常量（包含在“ ”中）的內容并不被搜索，替代，

我們來看下面一段代碼解釋一下第一條注意事項：

#include<stdio.h>
#define MUL(X) X * X
int main()
{
	int ret = MUL(3 + 2);
	printf("ret = %d\n", MUL(3 + 2));
	return 0;
}

運行結果如圖六：

我們的本意是想要對于3+2先進行加法，后進行平方，得到25

但是，實際上的結果是這樣進行運算的：

3 + 2 * 2 +3

得到11

所以，我們在書寫宏的時候，最好把每一個引數用()括起來，最后，把整個stuff用()括起來，避免在使用宏時引數中的運算子或臨近運算子之間不可預料的相互作用
如：

#define MUL(X) ((X) * (X))

這樣便能得到預期的答案 25

4.4 #：將宏的引數插入到字串中

使用#可以使一個宏引數變為對應的字串

#include<stdio.h>
int i = 20;
#define PRINT(VALUE,FORMAT) printf("the value of " #VALUE " is " FORMAT "\n",VALUE)
int main()
{
	PRINT(i+3, "%d");
	return 0;
}

運行結果如圖六：

可見，#宏引數名 == “宏引數名”，將引數名轉化成了一個字串

4.5 ##：前處理器粘合劑

使用##可以將宏的引數與其中的內容粘合起來

#include<stdio.h>
#define ANSWER(NUM,VALUE)\
answer##NUM = VALUE
int main()
{
	int ANSWER(1, 100);
	printf("answer1 = %d\n", answer1);
	return 0;
}

上述代碼中，answer便與NUM引數的值粘合了起來

值得一提的是，可以連續多次使用##將更多的引數粘合起來

4.6 宏與函式的對比

宏與函式的功能貌似有些相近，我們用表一來總結一下宏與函式的異同：

4.7 命名約定

我們有這樣一個命名約定，對于宏名，全部大寫；函式名，不要全部大寫

4.8 命令列定義

許多C語言編譯器提供了一種能力，允許我們在命令列中定義符號，用于啟動編譯，

請看下面的代碼：

#include<stdio.h>
int main()
{
	int arr[MAX];
	int i = 0;
	for (i = 0; i < MAX; i++)
	{
		arr[i] = i;
	}
	for (i = 0; i < MAX; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

我們可以看出，代碼中陣列大小 MAX 未定義，該源檔案名為test2.c

在Linux環境下，執行：

gcc -D MAX=100 test2.c

運行結果如圖七：

我們成功在命令列中對于MAx進行了定義，

4.9 移除宏定義

#define MAX 100

如果我們想對MAX重定義，一種方法是先將MAX移除，再定義

#undef MAX
#define MAX 10

4.10 條件編譯

在編譯一個程式的時候我們如果要將一條陳述句（一組陳述句）編譯或者放棄是很方便的，因為我們有條件編譯指令，

這有利于我們的除錯，

以下是常用的條件編譯指令：

1.當 #if 之后的陳述句為真，執行中間的命令

#if 1 == 1
...
#endif

2.多分支條件編譯

#if __MAX__
...
#elif __MIN__
...
#else
...
#endif

3.判斷是否被定義/未被定義

#ifdef
...
#endif

或

#if defined()
...
#endif

4.判斷是否未被定義

#ifndef
...
#endif

或

#if !defined()
...
#endif

5.嵌套指令

if defined(OS_UNIX) 
	#ifdef OPTION1
		unix_version_option1();
	#endif 
	#ifdef OPTION2 
		unix_version_option2();
	 #endif
#elif defined(OS_MSDOS) 
	#ifdef OPTION2
		msdos_version_option2();
	#endif
#endif

4.11 檔案包含

我們已經知道，#include 指令可以使另外一個檔案被編譯，

這種替換的方式很簡單： 前處理器先洗掉這條指令，并用包含檔案的內容替換， 這樣一個源檔案被包含10次，那就實際被編譯10次，

#include “ ” 

查找策略：先從自定義目錄中尋找頭檔案，若沒找到，去庫目錄中尋找

#include < >

查找策略：直接去庫目錄中尋找

那么，就會出現這樣一種情況：一個程式包括了若干個源檔案，而其中多個源檔案都參考了頭檔案，這樣就會導致嵌套檔案的情況發生，如圖八：

game1.c/game1.h與game2.c/game2/h 同時呼叫了lib.c/lib.h這一公共模塊，而test.c/test.h又同時呼叫了game1.c/game1.h與game2.c/game2/h，所以當test.c編譯時，會將lib.c/lib.h中的代碼重復編譯2次

解決方案1：
每個頭檔案開頭寫

#ifndef __JUD_H__
#define __JUD_H__ 100
頭檔案
#endif

解決方案2：
每個頭檔案開頭寫

#pragma once

4.12 #error

#error 是一種預編譯器指示字，用于生成一個編譯錯誤訊息 ，

用法：#error [message] //message為用戶自定義的錯誤提示資訊，可預設，

#error 編譯指示字用于自定義編譯錯誤訊息，

#if !defined(__cplusplus)
#error C++ compiler required.
#endif

5. 參考文獻

[1] C Primer Plus p521-563
[2] [GCC and Make Compiling, Linking and Building C/C++ Applications