翻译环境

C语言的代码是文本信息，对于计算机来说无法直接理解，需要通过翻译环境进行翻译成二进制信息；

我们在写代码的时候，一般都会写在一个源文件中，这时候我们就使用我们的编译器(VS)将其转换为机器代码，我们可以通过命令行的命令进行编译，通过命令就会生成一个可执行文件，我们就可以直接运行；

下图是运行的逻辑图：

编译

对于编译来说，也分几个阶段

运行环境

程序执行的过程：

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

预处理详解

预定义符号

FILE //进行编译的源文件

LINE //文件当前的行号

DATE //文件被编译的日期

TIME //文件被编译的时间

STDC //如果编译器遵循ANSI C，其值为1，否则未定义

示例代码：

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

#define 定义标识符

语法：

#define name stuff

示例代码：

#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定义标识符，后面不要加；这样会导致你把分号也加入到stuff，也会算进去定义

define 定义宏

#define允许把参数代入到文本中，这种实现称为宏（macro）；

宏的申明方式：

#define name( parament-list ) stuff

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

对于宏的申明方式，需要注意括号与name紧贴，不能有空格隔开，这样就会判定为是stuff的内容；

示例代码：

#include<stdio.h>
#define ADD(x,y) ((x)+(y))
int main()
{
    int a=ADD(3,5);
    printf("%d",a);
    //8
}

实际上这也是替换，ADD(3,5)在主程序中实际上就是3+5；对于宏的申明，对每个参数和最终值都要加上小括号，这样才比较严谨；

例如：

#define SQUARE( x ) x * x
int main()
{
    int a=5;
    //打印一个6*6的
printf("%d\n" ,SQUARE( a + 1) );
//实际上，5+1*5+1
}

对于宏来说，参数不会转换为一个最终值传过去，它只会照着你的参数形式原封不动的传过去，所以要加上小括号；

#define的替换规则

在程序中扩展#define定义符号和宏时，需要涉及几个步骤。

1.在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

3.最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意：

1 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

2 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

带副作用的宏参数

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

如：

x+1;//不带副作用
x++;//带有副作用

示例代码：

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int main()
{
    int x = 5;
    int y = 8;
    int z = MAX(x++, y++);
    printf("x=%d y=%d z=%d\n", x, y, z);
}

答案：x=6 y=10 z=9

由于后置加加的原因，所以对于这个宏来说，程序会进行先后顺序的执行；首先是5和8再比大小，由于8比较大，判断之后后置加加，返回值是9，x为5的后置加加就是6，而b判断之后又加了一次，所以是10；

所以不要使用带有副作用的参数；

#和##

如何把参数插入到字符串中？

nt main()
{
  printf("hello world\n");
  printf("hello ""world\n");
  return 0;
}

对于这段代码来说，打印结果都是一样的；字符串是有自动连接的特点；

看下面代码：

#define PRINT(FORMAT, VALUE) printf("the value is "FORMAT"\n", VALUE);
int main()
{
    PRINT("%d", 10);
}

结果：the value is 10

对于宏来说，把“%d"看作为字符串，将字符串内容进行插入；且只有当字符串作为宏参数的时候才可以把字符串放在字符串中。

而如果使用#，就会把宏的参数转换为对应的字符串；

#define PRINT(FORMAT, VALUE) printf("the value is "#FORMAT"\n", VALUE);
int main()
{
    PRINT("%d", 10);
}

结果：the value is “10”

多了一对双引号，表明把整个参数都带进去了；

示例代码：

#define PRINT(n, format) printf("the value of "#n" is " format "\n", n)
int main()
{
  int a = 20;
  //printf("the value of a is %d\n", a);
  PRINT(a, "%d");
  int b = 15;
  //printf("the value of b is %d\n", b);
  PRINT(b, "%d");
  float f = 4.5f;
  //printf("the value of f is %f\n", f);
  PRINT(f, "%f");
  return 0;
}

结果：

the value of a is 20

the value of b is 15

the value of f is 4.500000

如果在上面程序去掉#，程序将会报错；因为在字符串插入的并非是字符串，对于宏来说是错误的；

而##可以把位于它两边的符号合成一个符号。它允许宏定义从分离的文本片段创建标识符。

示例代码：

#define CAT(x,y) x##y
int main()
{
  int Class110 = 2024;
  printf("%d\n", CAT(Class, 110));
  printf("%d\n", Class110);
  return 0;
}

结果：

2024

2024

宏与函数对比

宏通常被应用于执行简单的运算。

如上面的简单的加法

#define ADD(x,y) ((x)+(y))

而不用函数的原因：

1, 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。

所以宏比函数在程序的规模和速度方面更胜一筹。

2.更为重要的是函数的参数必须声明为特定的类型。

所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以

用于>来比较的类型。

宏是类型无关的

宏的缺点：当然和函数相比宏也有劣势的地方：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
2. 宏是没法调试的。
3. 宏由于类型无关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

而对于函数和宏的命名，宏的命名一般都用大写字母，而函数一般是大小写字母结合；

#undef

如果对于已经下定义的名字已经被重复使用，或者不想用了，就用#undef

#undef NAME

条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令；

1：

#if 常量表达式

//…

#endif

通过判断常量表达式的真假来判断这段代码要不要编译

示例代码：

#define __DEBUG__ 1
#if __DEBUG__ //真
 //..
#endif

#if 常量表达式

//…

#elif 常量表达式

//…

#else

//…

#endif

与if条件判断一样，用通过判断哪个条件成立，其他条件就会被省略；

3.

#ifdef symbol
//…
#endif
#ifndef symbol
//…
#endif

判断是否被定义；

4.嵌套指令

#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

文件包含

#include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。

预处理器会对先对预指令进行删除,用文件中的内容进行替换;一个源文件如果被包含5次,那么就编译5次;

对于头文件的包含有两种形式;

第一种:

#include “filename”

本地文件包含:先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件;

找不到就是没有该头文件,程序报错;

第二种:

#include <filename.h>

库文件包含:查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

对于库文件包含于头文件包含的关系,头文件包含实际上包括着库文件包含;