c语言进阶学习笔记——程序环境和预处理

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

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

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

详解编译+链接

翻译环境

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

vs是一个集成开发环境，集成了很多功能，例如ctrl+F5就直接完成了很多功能，不方便观察细节，所以使用gcc这个编译器进行观察

汇编完之后生成目标文件，然后目标文件经过链接，变成可执行程序

如何查看编译期间的每一步发生了什么？

1. 预处理 选项 gcc -E test.c -o test.i
   预处理完成之后就停下来，预处理之后产生的结果都放在test.i文件中。
2. 编译 选项 gcc -S test.c
   编译完成之后就停下来，结果保存在test.s中。
3. 汇编 gcc -c test.c
   汇编完成之后就停下来，结果保存在test.o中。

预处理：

预处理过程中把头文件包含过来的时候需要进行梳理，所以代码量就没有直接打开头文件看到的多

编译：

这些分析就可以让c语言代码翻译成汇编代码

汇编：

链接：

把多个目标文件链接生成可执行程序

符号汇总->形成符号表->链接

局部变量是不会汇总的，这种局部变量只有函数运行起来才会创建，所以编译过程中是看不到这些局部变量的。如果有全局变量就会被汇总

合并段表、符号表的合并和重定位为链接期间在跨源文件的代码中找函数做铺垫
在形成的可执行程序中查找符号表，通过地址找函数如果函数名错误或者不存在，就会报出链接错误：无法解析的外部符号

如果一个函数被static修饰，那么这个函数就不会被符号汇总，也就是这个函数的外部链接属性变成了内部链接属性。

库：

运行环境

程序执行的过程：

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

预处理详解

预定义符号

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

这些预定义符号都是语言内置的，可以直接使用。

int main()
{
	int i = 0;
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (i = 0; i < 10; i++)
	{
		printf("%d----%s, %s, %s, line=%d\n", arr[i], __FILE__, __DATE__, __TIME__, __LINE__);
	}

	return 0;
}

VS不是严格遵循C语言标准的

int main()
{
	printf("%d\n", __STDC__);

	return 0;
}

补充：其实编译器在代码编译的时候，会对函数和变量名重命名的
在C语言中重命名的规则基本就是：加_
C++ 中会更加复杂

int main()
{
	printf("%s\n", __FUNCTION__);//函数名
	printf("%s\n", __FUNCDNAME__);//_函数名

	return 0;
}

#define

#define 定义标识符

举例

#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__ )  

当定义的stuff 过长，不能直接回车往下一行写，这时候就需要续行符 \
当我们写完\之后敲下回车键，续行符可以认为在转义换行，让它不是换行，编译器看来都还是在一行上。换行符后面不要跟一些其他字符，不然就不能转义换行了。

注意点：

在define定义标识符的时候，不要在最后加上 ;

比如：

#define MAX 1000;
#define MAX 1000

因为define是直接替换，当我们写int a=MAX;
虽然这样在替换后多了一个;多了一个语句也没什么问题但是遇到其他情况就有问题了。

错误情况：
替换后if语句后面跟的就是两条语句了，而else只跟了一条语句

 #define MAX 1000;

 int main()
 {
 	//int a = MAX;
     int a = 0;
     if(1)
         a = MAX;
     else
         a = -1;

 	return 0;
 }

#define 定义宏

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

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

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

预处理之后：

容易出现的问题：
因为是直接替换，所以操作符的优先级可能会对预想的结果产生影响
宏的参数不会进行计算再传。

可以改成：
#define SQUARE(x) ((x)*(x))
结果就不会被干扰了，外面加的括号是为了更保险

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

举例：
求两个值的最大值
用宏和函数都能实现

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

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

#define 替换规则

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

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

注意：

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

#和##

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

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

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

     return 0;
 }

当我们想写一个通用的代码

函数是做不到的，如：
n不能做到是变量名，格式也被固定了

补充：
c语言有一个特点：在打印字符串时，这些字符串会天然的连接在一起

打印结果是相同的

宏实现：

第一步：
解决格式问题

 #define print_format(num, format) \
             printf("the value of num is "format, num)

 int main()
 {
     int a = 10;
     print_format(a, "%d\n");
     //printf("the value of a is %d\n", a);

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

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

     return 0;
 }

format替换成"%d"就变成了"the value of num is" “%d”
如果给的是%f,那么就变成"the value of num is" “%f”

第二步：
把num变成对应的a，b或者f
想让参数num对应的实参名来到字符串中

可以先在num的前面和后面加上"

#define print_format(num, format) \
             printf("the value of "num" is "format, num)

那么num前面是字符串，num后面是字符串

如果num是个字符串，那么一连串都是字符串，连起来了

可以用#，#可以让参数变成所对应的字符串

#define print_format(num, format) \
             printf("the value of "#num" is "format, num)

预处理后：

这样是不行的：

如果传参传的是"a"也是可以的，不过不方便

##的作用

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

 int Class110 = 2023;

 #define CAT(x,y) x##y
 //Class110
 int main()
 {
     printf("%d\n", CAT(Class, 110));

     return 0;
 }

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

应用场景较少

带副作用的宏参数

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

副作用例子：

 int main()
 {
     //代码1
     int a = 10;
     int b = a+1;//b得到是11,a还是10

     //代码2
     int a = 10;
     int b = ++a;//b得到了11，但是a也变了，变成了11
     //代码2是有副作用的

     return 0;
 }

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

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

int main()
{
    int a = 3;
    int b = 5;
    //int c = MAX(a++, b++);
    int c = Max(a++, b++);
    //替换后 int c = ((a++)>(b++)?(a++):(b++));
    //                 3      5    
    printf("%d\n", c);//6
    printf("%d\n", a);//4
    printf("%d\n", b);//7
    
    return 0;
}

左值右值复习：

宏和函数

比如在两个数中找出较大的一个
可以用函数来实现，也可以用宏实现

//函数的实现 - 1
int Max(int x, int y)
{
	return x > y ? x : y;
}

//宏的实现 - 2
#define MAX(x,y)  ((x)>(y)?(x):(y))

int main()
{
	int a = 0;
	int b = 0;
	//输入
	scanf("%d %d", &a, &b);
	//较大值
	int m1 = Max(a, b);
	printf("%d\n", m1);

	int m2 = MAX(a, b);
	//int m2 = ((a)>(b)?(a):(b));
	printf("%d\n", m2);

	return 0;
}

这种运算选择宏实现更好，因为

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
   宏只需要进行主要运算
   所以宏比函数在程序的规模和速度方面更胜一筹。
   

2. 更为重要的是函数的参数必须声明为特定的类型。
   所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。
   宏是类型无关的。

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

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

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

#define MALLOC(num, type)   (type*)malloc(num * sizeof(type))

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		//....
	}

	int*p2 = MALLOC(10, int);
	if (p2 == NULL)
	{
		//....
	}
	//MALLOC(10, flaot);


	return 0;
}

宏和函数的对比

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

功能如果简单，可以用宏来实现
功能如果复杂，可以用函数来实现

命名约定

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

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

#undef

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

#include 

#define M 100

int main()
{
	printf("%d\n", M);

#undef M
	printf("%d\n", M);//err

	return 0;
}

命令行定义

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

//演示命令行定义

 int main()
 {
     int arr[SZ];
     int i = 0;
     for(i=0; i<SZ; i++)
     {
         arr[i] = i;
     }
     for(i=0; i<SZ; i++)
     {
         printf("%d ", arr[i]);
     }

     return 0;
 }

ctrl+·呼出终端窗口，然后
gcc -D SZ=10 test.c
在gcc环境下验证，在vs环境下不可行

条件编译

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

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

//#define __DEBUG__
 int main()
 {
     int arr[10] = {0};//0 1 2 3 4 5 6 7 8 9 
     int i = 0;
     for(i=0; i<10; i++)
     {
         arr[i] = i;
         #ifdef __DEBUG__
         printf("%d ", arr[i]);
         #endif
     }

     return 0;
 }

如果__DEBUG__没有被define定义，那么printf这条语句就不会参与编译

常见的条件编译指令：
1.

#if 常量表达式
 //...
#endif

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

#if 后面的表达式如果是真，那么printf这条语句参与编译
如果为假(1==2)，那么printf这条语句不参与编译

注意：

错误写法：
 int main()
 {
     int a=2;
     #if a==2
         printf("hehe\n");
     #endif
     return 0;
 }

这样是不对的，实际上printf并没有参与编译，局部变量a是在程序运行起来之后才创建的，这个预处理指令是在预编译阶段处理的，所以#if 后面要跟常量表达式

2.多个分支的条件编译

#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif

跟if else使用类似

3.判断是否被定义

两种方法都可以

#if defined(symbol)
#ifdef symbol

只要定义了条件就为真，即使是定义为0也是定义了
条件为真，语句就可以进行编译

#define MAX 0
 int main()
 {
      #if defined(MAX)
          priintf("hehe\n");
      #endif
     #ifdef MAX
         printf("hehe\n");
     #endif
     return 0;
 }

与其相反的：
没有定义就参与编译

#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 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。
这种替换的方式很简单：
预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际被编译10次。

头文件被包含的方式

本地文件包含

#include "test.h"

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

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

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径

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

库文件包含

#include 

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。
这样是不是可以说，对于库文件也可以使用 “” 的形式包含？
答案是肯定的，可以。
但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

嵌套文件包含

这样头文件会出现被重复包含的情况
解决方法1：

在当前头文件中
根据要引入的头文件的名字来命名一个合适的符号，比如是test.h,那么：

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
//如：
void InitContact(contact*pc,int sz);
#endif __TEST_H__

意思是：如果没有定义__TEST_H__那么就去定义
如果定义过，那么就不会再定义，避免了头文件被重复包含的问题
这样的话即使
#include"test.h"
#include"test.h"
#include"test.h"
#include"test.h"

test.h中的内容也只会包含一次

解决方法2：

#pragma once