程序环境和预处理

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

在ANSI C的任何一种实现中，存在两个不同的环境。
第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。
第2种是执行环境，它用于实际执行代码。

需要注意的是计算机只能识别二进制指令，这里的机器指令就是二进制指令。也就是讲源代码test.c需要经过翻译环境转变为机器指令。vs2019充当了这个翻译环境。

翻译完成就生成可执行程序了。

二、编译+链接

1.翻译环境

我们写代码时，每一个.c文件都会单独经过编译器生成obj目标文件，然后目标文件通过链接就可以变成可执行程序

假如我们已经写好了.c文件，这时我们先清理掉解决方案，然后再生成解决方案，就可以看到目标文件了。

2.编译的几个阶段

如下图，我们可以看到编译分三个阶段：预编译，编译，汇编


我们首先输入gcc test.c -E -o test.i
这时在test.i中可以看到头文件的包含，#define定义的符号的替换，以及注释的删除

然后输入gcc test.i -S 这里把c语言代码翻译成汇编代码

最后输入gcc test.s -c 这时就生成目标文件也就是test.o

注意我们在编译阶段有一个符号汇总的功能，这个符号汇总就是将所有的全局变量比如：g_val,Add,main等都汇总起来，
然后形成符号表就是将这些全局变量的符号都对应一个地址，

然后就是链接阶段会发生两件事：合并段表和符号表的合并和重定位

首先是合并段表。

合并段表是因为每一个test.o目标文件都有一个自己的段表，他们都是一个一个的段，但是他们最后只需要生成一个可执行程序，也就是一个段表。所以最终就会将这些段表给合并

然后是符号表的合并和重定位，如下图所示，在会汇编阶段，会生成两个符号表，在链接阶段会将这些符号表给合并成一个符号表。要使用有效的地址去合并

我们再来看一个这段代码，
这段代码的问题是将函数名写错了，这样编译器在合成符号表时，Add这个符号的地址0x0000是一个无效地址，从而无法解析这个外部符号

3 运行环境

程序执行的过程：

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

三、预处理

1.预处理符号

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("%s\n", __FUNCTION__);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

这里由于 STDC 报错，我们可得知vs2019不遵循ANSIC标准

2.#define

(1).#define 定义标识符

语法：
#define name stuff

举个例子

#define MAX 1000
1

#define reg register          //为 register这个关键字，创建一个简短的名字
1

define用于死循环

#define do_forever for(;;)     //用更形象的符号来替换一种实现
1

#define CASE break;case        //在写case语句的时候自动把 break写上。
1

// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
                          date:%s\ttime:%s\n" ,\
                         __FILE__,__LINE__ ,   \
                         __DATE__,__TIME__ )
1
2
3
4
5

注意：#define定义标识符时最好不要加上;
如果加上的话，容易出现问题

(2).#define 定义宏

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

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

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

但是这样的宏存在潜在的问题，因为宏只是一个替换，在下面的代码中被替换成1+71+7，达不成我们想要的（1+7）（1+7）的结果
也达不成我们想要的10*（4+4）的结果

如果想要正确使用，我们应该使用括号提高优先级，下面是正确写法

(3).#define 替换规则

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

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

注意：

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

(4).#和##

如何把参数插入到字符串中？#和##可以做到

首先我们来看下这段代码，

#include<stdio.h>
int main()
{
	printf("hello joshua\n");
	printf("hello"" joshua\n");
	return 0;
}
1
2
3
4
5
6
7

运行结果为：

也就是讲：我们发现字符串是有自动连接的特点的。

但是有时我们需要写这样的代码

这时我们发现打印的内容有大量是重复的，这是我们想要将这些重复的内容封装成一个宏，于是我们写出来以下的代码，但是x是在字符串里的，是无法被替换的。

为让定义的宏里的字符串中的x可以被参数替换，我们首先要将原来的字符串分隔开，
在x前加入#，这是#x的作用就是将x转换为"x"这个字符串，这样一来printf里就有三个字符串了，可以自动连接起来。代码实现如下：

有时我们也需要打印浮点数的数据，所以我们可以对宏进一步改造。

了解了#的作用，我们再来了解一下##的作用

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

#include<stdio.h>
#define CAT(x,y) x##y
int main()
{
	int helloworld = 2023;
	printf("%d\n", CAT(hello, world));
	return 0;
}
1
2
3
4
5
6
7
8

(5).带副作用的宏参数

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

例如

x+1;//不带副作用
x++;//带有副作用，得到结果的同时，x也发生变化了
1
2

这里是因为MAX这个宏只是一个替换，而不是像函数那样先计算再代入。
所以这个宏在预处理阶段处理后变成了
int m=((a++)>(b++)?(a++):(b++))

a一开始是3，b一开始是4，先引用后++，
在(a++)>(b++)?时，a=4，b=5，这时a比b小，执行的结果是b++；
也就是最后的结果是m=5，最后a=4，b=6.

而如果是函数的话，就不是发生替换，而是直接先引用a和b的值，然后再++，
所以结果为m=4，a=4，b=5

(6).宏和函数的对比

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

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

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

原因有二：

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

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

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

宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

#define MALLOC(num, type)\
 (type *)malloc(num * sizeof(type))
...
//使用
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int *)malloc(10 * sizeof(int));
比特
1
2
3
4
5
6
7
8

(7).命名约定

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

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

3.#undef

这个指令用来移除宏的定义

4.命令行定义

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

#include <stdio.h>
int main()
{
    int array [ARRAY_SIZE];
    int i = 0;
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        array[i] = i;
   }
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        printf("%d " ,array[i]);
   }
    printf("\n" );
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

编译指令：

//linux 环境演示
gcc -D ARRAY_SIZE=10 programe.c
1
2

5.条件编译

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

#include <stdio.h>
#define __DEBUG__
int main()
{
	 int i = 0;
	 int arr[10] = {0};
	 for(i=0; i<10; i++)
	{
		 arr[i] = i;
		 #ifdef __DEBUG__
		 printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 
		 #endif //__DEBUG__
	 }
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

常见的条件编译指令：

1.
#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值。
如
#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif
1
2
3
4
5
6
7
8
9
10

2.多个分支的条件编译
#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif
1
2
3
4
5
6
7
8

3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
1
2
3
4
5

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
1
2
3
4
5
6
7
8
9
10
11
12
13

6.文件包含

(1).文件包含的方式‘

• 本地文件包含
  #include "filename"
  查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标 准位置查找头文件。 如果找不到就提示编译错误。
• 库文件包含
  #include <filename.h>
  查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

这样是不是可以说，对于库文件也可以使用 “” 的形式包含？
答案是肯定的，可以。
但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

(2).嵌套文件包含

comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
test.h和test.c使用了test1模块和test2模块。
这样程序最终就会出现两份comm.h的内容，这样就造成了文件内容的重复。

我们可以使用条件编译去解决这个问题
每个头文件的开头写：

 #ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif   //__TEST_H__
1
2
3
4

如果没有定义，就定义，

或者使用这个指令

 #pragma once
1

四、其他预处理指令

#error
#pragma
#line
… 不做介绍，自己去了解。
#pragma pack()在结构体部分介绍。

参考《C语言深度解剖》学习

五、模拟实现offsetof宏

思路：第一个成员的偏移量是0，我们计算其他成员的偏移量时，可以用自己的地址减去第一个成员的地址
为了方便，我们可以将第一个成员的地址，也就是结构体的地址置于0处，然后我们只需计算其他成员本身的地址就可以得到偏移量了

• 将0强制类型转换为type*类型，就相当于结构体的起始地址位于0处
• 通过箭头访问操作符访问结构体成员，找到member的位置，再将地址取出来
• 将地址强制类型转换为sizez_t类型的

struct S
{
	char c1;
	char c2;
	int i;
};
#include<stdio.h>
#define OFFSETOF(type,member) (size_t)(&(((type*)0)->member))
int main()
{

	printf("%d\n", OFFSETOF(struct S, c1));
	printf("%d\n", OFFSETOF(struct S, c2));
	printf("%d\n", OFFSETOF(struct S, i));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

六、写一个宏，可以将一个整数的二进制位的奇数位和偶数位交换。

• 主要通过按位与和条件操作符来实现，我们知道一个数按位与1为原来的数，按位与0，则为0
• 首先，我们对所有偶数位按位与1，所有奇数位按位与0，也就是0101(十六进制为5)，将所有的偶数位取出来，再将其向右移，这样我们就将所有的偶数位
  移到奇数位了
• 然后，我们对所有奇数位按位与1，所有偶数位按位与0，也就是1010(十六进制为a),将所有的奇数位取出来，再将其向左移，这样我们就将所有的奇数位移到偶数位了
• 最后再加起来

#define SWAP(x) (((x&0x55555555)<<1)+((x&0xaaaaaaaa)>>1))
int main()
{ 
	int a = 1;
	printf("%d\n", a);
	a = SWAP(a);
	printf("%d\n", a);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

总结

本篇主要介绍了程序环境和预处理的相关知识，可以让我们更好理解程序是如何运行的。希望对你有所帮助。