程序运行环境（简介）预编译（详细）

一.程序运行环境过程

当我们写完代码后，程序是怎么运行成功的呢？

主要包括俩个部分 ：翻译环境（翻译环境包括预编译（编译器）和链接（连接器）） 和 执行环境 

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

1.翻译环境

1.1编译

1.1.1预编译

a.将#include 包含进来

b.将#define 替换到代码中

c.注释的删除

#include<stdio.h>
#define MAX 5
int main()
{
	//注释
	printf("%d", MAX);
	return 0;
}

预编译后：

#include<stdio.h>  //包含库函数的内容（这里做解释，可能将包含头文件的几千行代码）

int main()
{
	printf("%d", 5);
	return 0;
}

1.1.2编译

a.把源代码翻译位汇编代码

b.进行符号汇总等一系列操作

1.1.3汇编

a.将汇编代码转化为计算机读懂的二进制指令

b.形成符号表

1.2链接

a.合并段表

b.符号表的合并和重定义

2.执行环境

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

二.预处理

1.预定义符号

编译器本身带的预定义符号

__FINE__    //编译的源文件

__LINE__    //文件当前的行数

__DATE__   //文件被编译的日期

__TIME__   //文件被编译的时间

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

#include<stdio.h>
int main()
{
	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d 文件：%s 行数：%d 日期:%s 时间：%s\n", a[i],__FILE__,__LINE__,__DATE__,__TIME__);
	}
	return 0;
}

2.#define

2.1标识符定义

 语法：    #define name stuff
 

可以定义常量 ，字符，语句。注意：末尾不需要加；结尾，不然容易出错

#define MAX 100

#define MEMSRT MEM

#define FOR for(;;)

2.2宏定义

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

宏的申明方式：
#define name( parament-list )   stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中

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

#include<stdio.h>

//定义宏
#define MAX(x,y) （（x）>（y）?（x）:（y））

//定义宏
#define SPOR（x） (x)*(x)

int main()
{
	printf("%d ", MAX(3, 5));
    printf("%d ", SPOR(5));
	return 0;
}

预处理后，替换到代码中：

#define MAX(x,y) （（x）>（y）?（x）:（y））
#define SPOR（x） (x)*(x)

int main()
{
	printf("%d ",（（3）>（5）?（3）:（5））);
    //printf("%d ", MAX(3, 5));
    printf("%d ", (5)*(5));
    //printf("%d ", SPOR(5));

	return 0;
}

注意：尽量多使用（），以防bug出现

比如：假设我们不带（）

#define SPOR（x） x*x

int main()
{
     printf("%d",SPOR(1+2));
}

替换后 为 printf("%d",1+2*1+2)；与我们想要的结果有错

所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中
的操作符或邻近操作符之间不可预料的相互作用

2.3 #define 替换规则

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

2.4#和##

#：把一个宏参数变成对应的字符串

#define PRINT(FORMAT, VALUE) \
printf("the value of " #VALUE "is "FORMAT "\n", VALUE);

int main()
{
    int i = 10;
    PRINT("%d", i);
}

预编译后变成：

本来没加#时VALUE为 10，加了之后VALUE为i。

#define PRINT(FORMAT, VALUE) \
printf("the value of " #VALUE "is "FORMAT "\n", VALUE);

int main()
{
    int i = 10;
    printf("the value of " i "is "%d "\n", VALUE);
}

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

例如：##将num和sum合并在一起（num为5）合在一起就是sum5

#define ADD_TO_SUM(num, value) \
sum##num += value;
...
ADD_TO_SUM(5, 10);//作用是：给sum5增加10.

//预编译后为sum5 += 10;

2.5带副作用的宏参数

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

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

x++会改变x的值。

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

结果是：x和y的值都发生了变化，求的较大值也发生改变

 2.6宏和函数的对比

属 性	#define定义宏	函数
代 码 长 度	每次使用时，宏代码都会被插入到程序中。除了非常 小的宏之外，程序的长度会大幅度增长	函数代码只出现于一个地方；每 次使用这个函数时，都调用那个 地方的同一份代码
执 行 速 度	更快	存在函数的调用和返回的额外开 销，所以相对慢一些
操 作 符 优 先 级	宏参数的求值是在所有周围表达式的上下文环境里， 除非加上括号，否则邻近操作符的优先级可能会产生 不可预料的后果，所以建议宏在书写的时候多些括 号。	函数参数只在函数调用的时候求 值一次，它的结果值传递给函 数。表达式的求值结果更容易预 测。
带 有 副 作 用 的 参 数	参数可能被替换到宏体中的多个位置，所以带有副作 用的参数求值可能会产生不可预料的结果。	函数参数只在传参的时候求值一 次，结果更容易控制。
参 数 类 型	宏的参数与类型无关，只要对参数的操作是合法的， 它就可以使用于任何参数类型。	函数的参数是与类型有关的，如 果参数的类型不同，就需要不同 的函数，即使他们执行的任务是 相同的。
调 试	宏是不方便调试的	函数是可以逐语句调试的
递 归	宏是不能递归的	函数是可以递归的

2.7 命名约定

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

3.#undef

作用：移除#define定义

#define MAX 5

int mian()
{
    printf("%d",MAX);
#undef
    printf("%d",MAX);
    RETURN 0;
}

第一个可以打印出来，第二个就报错了，因为移除了MAX的定义，所以第二个就会报错

4.条件编译

常见的条件编译指令：

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

#if __DEBUG__
//..
#endif

2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif
3.判断是否被定义

#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

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

后面的表达式为真就执行，和if语句非常相似

5.文件包含

5.1文件包含方式

5.1.1本地文件包含

例如：#include"text.h"  先在工程的本地文件下面找文件，如果找不到就到库文件里面找。找不到就编译错误，报错了。

5.1.2库文件包含

例如：#include<stdio.h> 直接去标准路径下寻找库文件，找不到就报错。

所以头文件包含也可以用#include"stdio.h"包含，但是这样效率就会变低了。

5.2文件的嵌套包含

 text.c文件就会包含多次的comm.h文件，文件的内容很多的话，重复就会造成很大的浪费。

为了避免这种情况：

1.条件编译方法

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif //__TEST_H__

没有定义就定义，定义之后就不执行。

2.加入#pragma once

加入这个定义就可以避免头文件的重复引用。