程序环境和预处理

一、程序的翻译环境和执行环境

在ANSIC的任何一种实现中，存在两个不同的环境。

第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码。

二、详解编译+链接

1.翻译环境

2.编译本身也分为几个阶段

推荐阅读：《程序员的自我修养》

3.运行环境

程序执行的过程：
1.程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。
2.程序的执行便开始。接着便调用main函数。
3.开始执行程序代码。这个时候程序将使用函数栈帧，存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程一直保留他们的值。
4.终止程序。正常终止main函数；也有可能是意外终止。

三、预处理

1.预定义符号

__FILE__//进行编译的源文件 __LINE__//文件当前的行号 __DATE__//文件被编译的日期 __TIME__//文件被编译的时间 __STDC__//如果编译器遵循ANSIC，其值为1，否则未定义

#include<stdio.h> int main() { int i = 0; for (i = 0;i < 10;i++) { printf("\n\n%d\n", i); printf("%s\n", __FILE__); printf("%s\n", __TIME__); printf("%d\n", __LINE__); printf("%s\n", __DATE__); } return 0; }

2.define

①define定义标识符

可以是字符串、整形，甚至是一段代码

#include<stdio.h> #define MAX 100 #define STR "hello world" #define print printf("hi!\n") //define后面不要加分号！！！ int main() { printf("%d\n", MAX); //100 printf("%s\n", STR); //hello world print; //hi! return 0; }

#define MAX 1000 #define reg register //为register这个关键字，创建一个简短的名字 #define do_forever for(;;) //用更形象的符号来替换一种实现 #define CASE break;case //在写case语句的时候自动把break写上。 //如果定义的stuff过长，可以分成几行写 //除了最后一行外，每行的后面都加一个反斜杠（续行符）。 #define DEBUG_PRINT printf("file:%s(tline:%d\t\ date:%s\ttime:%s\n",\ __FILE__,__LINE__,\ __DATE__,__TIME__)

②define定义宏

#define机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏(define macro)。

下面是宏的申明方式：

#define name(parament-list) stuff //宏名 //参数列表 //文本

其中的parament-list是一个由逗号隔开的符号表，它们可能出现在stuff中

注意：
参数列表的左括号必须与name紧邻。
如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

#include<stdio.h> #define SQURE(x) ((x)*(x)) int main() { int n = SQURE(5); printf("%d", n);//25 return 0; }

③#define替换规则

在程序中扩展#define定义符号和宏时，需要涉及几个步骤。
1.在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先
被替换。
2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
3.最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上
述处理过程。

注意:
1.宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
2.当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

④#

Ⅰ.两个字符串会自动连接

#include<stdio.h> int main() { printf("hello world\n"); printf("hello"" world\n"); //都得到hello world return 0; }

Ⅱ.会替换成： "the value of " + "a" + " is 5\n"

#N:把参数（a）插入字符串中

#include<stdio.h> #define PRINT(N) printf("the value of "#N" is %d\n",N) int main() { int a = 5; PRINT(a); int b = 10; PRINT(b); return 0; }

Ⅲ.打印多种类型的变量

#include<stdio.h> #define PRINT(N,FORMAT) printf("the value of "#N" is "FORMAT"\n",N) int main() { int a = 10; PRINT(a, "%d"); float f = 3.14f; PRINT(f, "%lf"); return 0; }

⑤##

##可以把位于它两边的符号合成一个符号。

它允许宏定义从分离的文本片段创建标识符。

#include<stdio.h> #define CAT(Class,Num) Class##Num int main() { int Class106 = 100; printf("%d\n", CAT(Class, 106)); //等价于 //printf("%d\n", Class106); return 0; }

注：
这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

⑥带副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。

int a=10; //无副作用 int b=a+1; //带有副作用 //b改变的同时，a也改变了 int b=++a;

错误示范:

#include<stdio.h> #define MAX(x,y)((x)>(y)?(x):(y)) int main() { int a = 5; int b = 4; int m = MAX(a++, b++); //m=MAX((a++)>(b++)?(a++):(b++)) // 6 5 7 //m=6 //a=7 //b=5 printf("%d %d %d", m, a, b); return 0; }

⑦宏和函数对比

宏通常被应用于执行简单的运算。
比如在两个数中找出较大的。

#define MAX(a, b) ((a)> (b)? (a): (b))

那为什么不用函数来完成这个任务？

原因有二：

1.用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
所以宏比函数在程序的规模和速度方面更胜一筹。

2.更为重要的是函数的参数必须声明为特定的类型。
所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以
用于>来比较的类型。
宏是类型无关的。

宏的缺点：
1.每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。

2.宏是没法调试的。

3.宏由于类型无关，也就不够严谨。

4.宏可能会带来运算符优先级的问题，导致程容易出现错。

函数不可以传类型，但宏可以

#include<stdio.h> #include<stdlib.h> #define MALLOC(num,type)(type*)malloc(num)*sizeof((type)) int main() { int* p = MALLOC(10, int); //等价于 //int* p = (int*)malloc((10) * sizeof(int)); return 0; }

⑧命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。
那我们平时的一个习惯是：

把宏名全部大写
函数名不要全部大写

3.#undef

用于移除一个宏定义

#include<stdio.h> #define M 100 int main() { printf("%d", M); #undef M printf("%d", M); //会报错：未定义标识符M return 0; }

4.命令行定义

许多C的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。
例如：当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些。）

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

linux环境演示：

gcc -D ARRAAY_SIZE=10 programe.c

5.条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。
比如说：调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

#include<stdio.h> #define __DEBUG__ //如果删掉这行代码，debug未定义， //条件为假，中间的语句就不参与编译 int main() { int i = 0; int arr[10] = { 0 }; for (i = 0;i < 10;i++) { arr[i] = i; #ifdef __DEBUG__ //如果定义了debug，条件为真，参与编译 printf("%d\n", arr[i]); #endif //__DEBUG__ } return 0; }

常见的条件编译指令：

1.

#if 常量表达式
//..
#endif

#include<stdio.h> int main() { #if 1 printf("hello\n"); //hello #endif return 0; }

#include<stdio.h> int main() { #if 0 printf("hello\n"); //什么也没有 #endif return 0; }

//常量表达式由预处理器求值。
如：
#define _DEBUG_1
#if _DEBUG
//...
#endif

2.多个分支的条件编译

#if 常量表达式
//...
#elif 常量表达式
//...
#else
//..
#endif

#include<stdio.h> #define M 6 int main() { #if M<5 printf("hello!!!\n"); #elif M==5 printf("What's Your Name?\n"); #else printf("I Love You!\n"); //I Love You! #endif return 0; }

3.判断是否被定义

#if defined(symbol)

#include<stdio.h> #define MAX 100 int main() { #if defined(MAX) printf("max\n"); //max #endif return 0; }

#ifdef symbol

#include<stdio.h> #define MAX 100 int main() { #ifdef MAX printf("max\n"); //max #endif return 0; }

#if !defined(symbol)

#include<stdio.h> //#define MAX 100 int main() { #if !defined(MAX) printf("max\n"); //max #endif return 0; }

#ifndef symbol

#include<stdio.h> //#define MAX 100 int main() { #ifndef MAX printf("max\n"); //max #endif return 0; }

4.嵌套指令

#if defined(oS_UNIX) #ifdef OPTIONL unix_version_optionl(); #endif #ifdef OPTION2 unix_version_option2(); #endif #elif defined(os_MSDOS) #ifdef OPTION2 msdos_version_option2(); #endif #endif

6.文件包含

我们已经知道，#include指令可以使另外一个文件被编译。就像它实际出现于#include指令的地方
—样。
这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。这样一个源文件被包含10次，那就实际被编译10次。

①防止头文件被多次重复包含

写法一：

#ifndef __TEST_H__ //如果没有定义__TEST_H__,条件为真 //下面的代码参与编译 #define __TEST_H__ //第一次包含头文件的时候没有定义过__TEST_H__ //先把__TEST_H__定义了 int ADD(int x, int y); #endif //第二次再想包含的时候ifndef条件为假 //不会产生效果

写法二：

#pragma once

②<>和 "" 的区别是查找的策略不同

#include<stdio.h>
直接去库目录下查找

#include"test.h"
先去代码所在的路径下查找
如果上面找不到，再去库目录下查找

③头文件被包含的方式：

●本地文件包含
#include "filename"
查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。
如果找不到就提示编译错误。
Linux环境的标准头文件的路径：
/usr/include
VS环境的标准头文件的路径：
C:\Program Files (x86)\Microsoft Visual Studio 12.0\vc\include
//这是vS2013的默认路径

注意按照自己的安装路径去找。
●库文件包含
#include <filename.h>
查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。
这样是不是可以说，对于库文件也可以使用“”的形式包含？
可以。但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

④嵌套文件包含

四、其他预处理指令

【拓】百度笔试题：

写一个宏计算结构体中某变量相对于首地址的偏移，并给出说明
（考察：offsetof宏的实现）

1.普通写法

#include<stdio.h> #include<stdlib.h> struct S { char c1; int i; char c2; }; int main() { struct S s = { 0 }; printf("%d\n", offsetof(struct S, c1));//0 printf("%d\n", offsetof(struct S, i));//4 printf("%d\n", offsetof(struct S, c2));//8 return 0; }

2.宏的写法

假设0地址处放一个结构体，把它强制类型转换成结构体指针，当成一个结构体地址

拿到结构体成员，&取出成员地址

#include<stdio.h> #define OFFSETOF(type,member_name) (size_t)&(((type*)0)->member_name) struct S { char c1; int i; char c2; }; int main() { struct S s = { 0 }; printf("%d\n", OFFSETOF(struct S, c1));//0 printf("%d\n", OFFSETOF(struct S, i));//4 printf("%d\n", OFFSETOF(struct S, c2));//8 return 0; }