编译过程

编译过程简介：

 预编译：gcc -E file.c -o file.i

处理注释，以空格代替

将宏定义展开

处理条件编译指令

处理#include，展开被包含的文件

保留编译器需要使用的#pragma指令

编译： gcc -S file.i -o file.s

对预处理文件进行词法分析，语法 分析，语义分析

汇编：gcc -c file.s -o hello.o

将汇编代码翻译成机器码

链接：

将各个模块之间的相互引用的部分处理好，使得各个模块之间能够正确的衔接。将各个独立的模块链接成可执行的程序

静态链接：各个模块简单连接，编译期完成

动态链接：共享库文件，运行期完成

 

定义宏常量：

#define定义宏常量，可以出现咋代码的任何地方；从定义行开始，之后的代码都可使用这个宏常量（不管是否在某个函数中定义）

定义宏表达式：

#include <stdio.h>
int f1(int a, int b)
{
    #define _MIN_(a,b) ((a)<(b) ? a : b)    
    return _MIN_(a, b);
}
int f2(int a, int b, int c)
{
    return _MIN_(_MIN_(a,b), c);
}
int main()
{
    printf("%d\n", f1(2, 1));
    printf("%d\n", f2(5, 3, 2));   
    return 0;
}

宏表达式的域：自定义行开始之后的所有代码都可以使用

定义宏只能在一行中完成，（使用接续符换行）

宏表达式与函数的对比：
宏表达式在预编译的过程中被处理，编译器不知道宏表达式的存在；宏表达式用实参 完全代替形参，不进行任何运算；宏表达式没有任何的调用开销；宏表达式不能出现递归定义。

#define func(n) ((n>0) ? func(n-1) : 0 ); //错误，递归定义宏

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

条件编译的使用：

条件编译是预编译指示命令，用于控制是否编译某段代码；执行行为类似：if else语句。

#if (exp1)
....;
#else
...;
#endif

#include：
本质：将已经存在的文件内容，复制到当前文件中。（预编译中完成）

// global.h
int global = 10;

// test.h
#include <stdio.h>
#include "global.h"

const char* NAME = "Hello world!";

void f()
{
    printf("Hello world!\n");
}

// test.c
#include <stdio.h>
#include "test.h"
#include "global.h"

int main()
{
    f();
    
    printf("%s\n", NAME);
    
    return 0;
}

编译test.c时，由于global.h同时在test.h中包含了，又在test.c中包含了，这样int global = 10;就在test.c中重复了两次，定义了两次，提示出错。

// global.h
#ifndef _GLOBAL_H_
#define _GLOBAL_H_
int global = 10;
#endif

// test.h
#ifndef _TEST_H_
#define _TEST_H_
#include <stdio.h>
#include "global.h"
const char* NAME = "Hello world!";
void f()
{
    printf("Hello world!\n");
}
#endif

// test.c
#include <stdio.h>
#include "test.h"
#include "global.h"

int main()
{
    f();  
    printf("%s\n", NAME);  
    return 0;
}

使用条件编译，可以保证前面包含进来的（复制进来）内容，不再重复复制，而不管你写了多个头包含语句。

#error和#line：

#error用于生成一个编译错误信息，并停止编译

#error message  //message不需要使用双引号包围，message是程序员自定义的信息

#warring 用于生成警告，但不停止编译

#include <stdio.h>
#define CONST_NAME1 "CONST_NAME1"
#define CONST_NAME2 "CONST_NAME2"
int main()
{  
    #ifndef COMMAND
    #warning Compilation will be stoped ...
    #error No defined Constant Symbol COMMAND
    #endif
    printf("%s\n", COMMAND);
    printf("%s\n", CONST_NAME1);
    printf("%s\n", CONST_NAME2);
    return 0;
}

#line用于强制指定新的行号和编译文件名，并对源程序的代码重新编号
本质：是重定义_LINE_和_FINE_(内部宏定义)

用法：#line number filename

#include <stdio.h>
#line 14 "Hello.c"   //__LINE__=14,即下一行行号为14;__FILE__="Hello.c"
#define CONST_NAME1 "CONST_NAME1"
#define CONST_NAME2 "CONST_NAME2"
void f()
{
    return 0;  // 该行行号为20，提示出错
}
int main()
{
    printf("%s\n", CONST_NAME1);
    printf("%s\n", CONST_NAME2);
    printf("%d\n", __LINE__);  //27
    printf("%s\n", __FILE__);  //hello.c  
    f();  
    return 0;
}

#pragma:

#pragma是编译器指示字，用于指示编译器完成一些特定的动作；它所定义的很多指示字是编译器和操作系统特有的；在不同的编译器间不可移植。

预处理器将忽略它不认识的#pragma指令

两个不同的编译器可能以两种不同的方式解释同一条#pragma指令

#pragma message

 

#和##号运算符：

#用于在预编译期将宏参数转换为字符串，注意：是在预编译期完成

#include <stdio.h>
#define CONVERS(x) #x  //#用于将CONVERS(x)中的x转换为x字符串
int main()
{   
    printf("%s\n", CONVERS(Hello world!)); //Hello world!
    printf("%s\n", CONVERS(100)); //100
    printf("%s\n", CONVERS(while)); //while
    printf("%s\n", CONVERS(return)); //return
    return 0;
}

#include <stdio.h>
#define CALL(f, p) (printf("Call function %s\n", #f), f(p))   
int square(int n)
{
    return n * n;
}

int f(int x)
{
    return x;
}

int main()
{
    printf("1. %d\n", CALL(square, 4));
    // Call function square 
    //1.16
    printf("2. %d\n", CALL(f, 10)); 
    //Call function f
    //2.10
    return 0;
}

##用于在编译期粘连两个符号：

#include <stdio.h>
#define NAME(n) name##n
int main()
{   
    int NAME(1);
    int NAME(2); 
    NAME(1) = 1;
    NAME(2) = 2; 
    printf("%d\n", NAME(1)); //1
    printf("%d\n", NAME(2)); //2
    return 0;
}