C语言学习笔记（19）程序环境和预处理

Posted 2021-08-28 小倪同学 -_-

文章目录

• 程序的翻译环境和执行环境
• • 翻译环境（编译+链接）
  • • 预处理
    • 编译
    • 汇编
  • 运行环境
• 预处理
• • 预定义符号
  • #define
  • • #define定义标识符
    • #define定义宏
    • #define替换规则
    • #和##
    • 带副作用的宏参数
    • 宏和函数的对比
  • #undef
  • 命令行定义
  • 条件编译
  • 文件包含
  • • 头文件被包含的方式
    • 嵌套文件包含

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

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

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

翻译环境（编译+链接）

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

编译又分为预处理，编译，汇编三个阶段

预处理

在Linux中通过gcc test.c -E预处理生成一个test.i文件

完成了

1. 头文件的包含（#include）
2. #define定义的符号和宏的替换
3. 注释删除

编译

在Linux中通过gcc test.i -S生成一个test.s文件,将C语言代码转化成汇编代码

完成了

1. 语法分析
2. 词法分析
3. 语义分析
4. 符号汇总

汇编

在Linux中通过gcc test.s -c生成一个test.o(test.obj)文件,把汇编代码转化成了机器指令（二进制指令）
生成符号表

运行环境

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

预处理

预定义符号

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

这些预定义符号可以帮助我们记录一些日志信息

例

#include<stdio.h>
int main()
{
	FILE* pf = fopen("log.txt", "a+");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		fprintf(pf, "%s %d %s %s %d\\n", __FILE__, __LINE__, __DATE__, __TIME__, i);
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

#define

#define定义标识符

#define M 1000  //定义常量
#define reg register  //为register关键字创建一个简短的名字
#define do_forever for(;;)  //定义一条语句
#define CASE break;case  //定义一些方便使用的操作

int main()
{
	int N = M;
	reg int num = 0;
	do_forever;

	int n = 0;
	switch (n)
	{
		case 1:
		CASE 2 ://定义为break;case 2
		CASE 3 :
	}
	return 0;
}

在define定义标识符的时候，最好不要在最后加上 ;可能会导致如下错误

#define M 1000;

int main()
{
	int a = 10;
	int b = 0;
	if (a > 10)
		b = M;//这里被看为两条语句：b=1000; ;
	else
		b = -M;

	return 0;
}

#define定义宏

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

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

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

#define SQUARE(X) ((X)*(X))//注意括号

int main()
{
	printf("%d\\n", SQUARE(3+1));//16
	return 0;
}

#define替换规则

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

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

注意：

• 宏参数和#define定义中可以出现其它#define定义的常量。但是对于宏，不能出现递归，因为宏只做简单的文本替换，且只替换一次
• 当预处理器搜索#define定义的符号时，字符串常量的内容并不被搜索

#define M 100

#define MAX(X, Y) ((X)>(Y)?(X):(Y))

int main()
{
	int max = MAX(101, M);//M优先被替换
	printf("M = %d\\n", M);//第一个M不会被替换

	return 0;
}

#和##

#的作用是把一个宏参数变成对应的字符串

应用：

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

int main()
{
	int a = 10;
	PRINT(a, "%d");//该语句相当于printf("the value of ""a"" is "%d"\\n", a);

	int b = 20;
	PRINT(b, "%d");//printf("the value of ""b"" is "%d"\\n", b);

	float f = 5.5f;
	PRINT(f, "%f");//printf("the value of ""f"" is ""%f""\\n", f);

	return 0;
}

##连接左右两个符号

例：

#define CAT(X,Y,Z) X##Y##Z

int main()
{
	int code101101 = 100;
	printf("%d\\n", CAT(code, 101, 101));

	return 0;
}

带副作用的宏参数

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

例：

#define MAX(X,Y) ((X)>(Y)?(X):(Y))

int Max(int x, int y)
{
	return x > y ? x : y;
}

int main()
{
	int a = 5;
	int b = 8;

	int m = MAX(a++, b++);
	printf("a=%d b=%d\\n", a, b);
	printf("m = %d\\n", m);

	return 0;
}

代码中int m = MAX(a++, b++);可替换为int m = ((a++) > (b++) ? (a++) : (b++));
1.计算a++得a=6;2.计算b++得b=9;3.求得m=9;4.计算b++得b=10

宏和函数的对比

观察如下求最大值代码

#define MAX(X,Y) ((X)>(Y)?(X):(Y))
int max(int x, int y)
{
	return x > y ? x : y;
}
int main()
{
	int a = 5;
	int b = 8;
	return 0;
}

这里用宏求最大值是有优势的

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。宏是类型无关的。

但是宏也有许多劣势

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

宏和函数的对比

命名约定
一般来讲函数和宏的使得语法很相似。所以语言本身没帮我们区分二者，我们平时的一个习惯是：

1. 把宏名全部大写
2. 函数名不要全部大写

#undef

用于移除一个宏定义

#define M 100
int main()
{
	int a = M;
#undef M
	printf("%d\\n", M);//移除宏定义后，M不能再使用
	return 0;
}

命令行定义

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

条件编译

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

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

常见的条件编译指令：

1.
#if 常量表达式 (如果为真则编译，否则不编译)
//...
#endif

int main()
{
#if 1 
	printf("hehe\\n");
#endif
	return 0;
}


2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif

int main()
{
#if 1==1
	printf("hehe\\n");
#elif 1==2
	printf("haha\\n");
#else 
	printf("heihei\\n");
#endif
	return 0;
}

3.判断是否被定义
(1)
int main()
{
#ifndef name1 //如果name1未定义，下面的语句则参与编译
...
#endif
return 0;
}
(2)
int main()
{
#if !defined(name2)//如果name2未定义，下面的语句则参与编译
...
#endif
return 0;
}

int main()
{
#ifndef HEHE
	printf("hehe\\n");
#endif
	return 0;
}

4.嵌套指令
#if define(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 指令的地方一样。
这种替换的方式很简单︰
预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际被编译10次。

头文件被包含的方式

1.本地文件包含（“ ”）
先在源文件所在的目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件，如果找不到就提示编译错误 (” "也可以包含库文件，但是效率低下 )

2.库文件包含（< >）
查找头文件直接去标准路径下查找，如果找不到就提示编译错误

嵌套文件包含

如何避免头文件的重复引入

1. 使用#pragma once,这条语句的作用是该文件头文件只会包含一次。
2. 利用如下代码避免头文件的重复包含

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