程序环境和预处理

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

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

第2种是执行环境，它用于实际执行码。

详解编译+链接

翻译环境

组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。 链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库， 将其需要的函数也链接到程序中

编译的几个阶段

预编译:预处理指令

test.i

编译;语法分析，词法分析，语义分析，符号分析

test.s

汇编：汇编指令->二进制指令

test.o

链接：相关文件链接

预处理详解

预定义符号

语言内置，直接使用

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

例如：

void log(char *filename, size_t line, char *time, char *msg)
{
	printf("%s : %s : %d ==> %s\n", filename,  time, line, msg);
}

#define LOG(msg) log(__FILE__, __LINE__, __TIME__, msg)

void main()
{
	FILE *fp = fopen("test1.txt", "r");
	if(fp == NULL)
	{
		LOG("Open test1.txt failed.");
		return;
	}
	printf("Open File OK.\n");
	fclose(fp);
}

#define

#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 定义宏

#define 机制包括了一个规定，允许把参数替换到文本中，

这种实现通常称为宏（macro）或定义宏（definemacro）。

严格替换参数！

#define MUL(a, b) ((a) * (b))
#define MULII(a,b) a*b
#define MULIII(a,b) (a)*(b)

void main()
{
    //有何不同?   实行严格替换
    int res1=MUL(1+2,2*3);
    int res2=MULII(1+2,2*3);	//1+2 * 2*3
    int res3=MULIII(1+2,2*3);
}

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

#define替换规则

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

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

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

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

注意：

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

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

#和##

#

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

#define SQUARE( x ) printf(#x "*" #x "= %d\n", x*x) 
void main() 
{ 
    SQUARE(50); 
}

##

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

#define STU_NAME(NAME)  struct bit_##NAME##_stu{	int a;int b;}

STU_NAME(zs);

void main()
{
	struct bit_zs_stu s;
}


#define ADD_TO_SUM(num, value)  sum##num += value; 

void  main()
{
	int sum5 = 0;
	
	ADD_TO_SUM(5, 10);

	sum5 += value; 
}

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

副作用的宏参数

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);

z = ( (x++) > (y++) ? (x++) : (y++));

x=6 y=10 z=9

命名约定

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

#undef

这条指令用于移除一个宏定义。

#undef NAME //如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。

条件编译

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

调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

void log(char *filename, size_t line, char *time, char *msg)
{
	printf("%s : %s : %d ==> %s\n", filename,  time, line, msg);
}

#define LOG(msg) log(__FILE__, __LINE__, __TIME__, msg)

void main()
{
	FILE *fp = fopen("test1.txt", "r");
	if(fp == NULL)
	{
#ifdef ASSERT
		LOG("Open test1.txt failed.");
#endif
		return;
	}
	printf("Open File OK.\n");
	fclose(fp);
}

常见的条件编译指令

#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

文件包含

头文件被包含的方式：

本地文件包含

#include "filename"

查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。 如果找不到就提示编译错误。 linux环境的标准头文件的路径：/usr/include

VS环境的标准头文件的路径：

C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include

注意按照自己的安装路径去找。

库文件包含

#include <filename.h>

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

可以避免头文件的重复引入

每个头文件的开头写：

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

或者：

#pragma once

最难不过坚持！