一起来学习C语言的程序环境与预处理

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

要支持c语言的实现，会有不同的编译器出现，而这些编译器都要遵循ANSI C，都存在两种环境

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

.obj为后缀的就是目标文件

而一个项目中可能会有很多.c后缀的源文件，分别处理后每经过编译器单独处理，然后会生成对应的目标文件（.obj），然后总体经过连接器处理，最终变成可执行程序。

目标文件最后还要加上链接库整体一起通过链接器链接，变成可执行程序.

链接库：在编写代码的时候，会有一些不属于我们自己写的函数（如printf），这些函数是自带的库里面包含的，这些库就叫链接库

（补函数的声明与定义里面的静态库）

从源文件生成可执行程序的这一个过程就叫做翻译环境

2.gcc C语言编译器来演示编译过程

2.1编译

预编译→编译→汇编

预编译（预处理）：

文本操作：

1.头文件的包含，#include——预编译指令，将包含的头文件给展开

2.删除注释（注释被空格替换）

3.#define定义符号的替换

2.2编译：

生成.s的文件

把c语言代码转换成汇编代码

1.语法分析

2.词法分析

3.语义分析

4.符号汇总——汇总的是全局符号

《程序员的自我修养》——通俗地讲解代码编译过程的细节

汇编：

生成了test.o

把汇编代码转换成二进制指令

形成符号表：

框内是十六进制是地址

链接：

最终将.o文件链接成.exe可执行程序

1.合并段表

2.符号表的合并和重定位（像Add一开始地址为默认0和另一个.c文件内的Add地址的为0x200，会重新定位）

符号表的意义：多个目标文件进行链接的时候会通过符号表查看来自外部的符号是否真实存在

2.3运行环境

1.程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排（电焊好伐），也可能是通过可执行代码置入只读内存来完成。

2.程序的执行便开始。接着便调用main函数。

3.开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack）（也就是之前博客中写到的函数栈帧的创建与销毁），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程一直保留他们的值。

4.终止程序。正常终止main函数；也有可能是意外终止。

3详解预处理

3.1预定义符号

• __DATE__
• __FILE__
• __LINE__
• __TIME__
• __STDC__   //如果编译器遵循ANSI C，其值为1，否则未定义

作用：记录日志：可记录在哪个文件在哪个日期在什么时候在哪个文件在哪一行

#define _CRT_sECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
    printf("%s\n", __FILE__);
    printf("%s\n", __TIME__);
    printf("%d\n", __LINE__);
    printf("%s\n", __DATE__);
    return 0;
}

预处理符号的应用：

//预处理符号的应用——写日志
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
    int i = 0;
    FILE* pf = fopen("test.txt", "w");
    if (NULL == pf)
    {
        printf("error is%s\n", strerror(errno));
        return 0;
    }
    for (i = 0; i < 5; i++)
    {
        fprintf(pf, "%s\t%s\t%s\t%d\ti=%d\n", __FILE__, __DATE__, __TIME__, __LINE__, i);
    }
    fclose(pf);
    pf = NULL;
    return 0;
}

3.2#define

3.2.1#define定义标识符

两种用法：

#define MM 100
#define reg reGISter——关键字替换
 

#define末尾有时候可以加分号有时又不可以加上分号，

不可以加上分号的情况：

//不可以加上分号的情况
#define _CRT_SECURE_NO_WARNINGS 1
#define MAX(x,y) ((x)>(y)?x:y);
#include <stdio.h>
int main()
{
    int a = 5;
    int b = 3;
    printf("%d\n", MAX(a, b));
    return 0;
}

因为加上分号会使得宏在替换的时候也带上分号，所以在调用在一些函数内部的时候会出现错误。

综上，当我们定义宏的时候，最好不要加分号在末尾。

3.2.2 #define定义宏

这里也是将全部参数给替换掉，在预处理的时候就替换掉了，不信的话可以在解决方案处右击，点击属性后选择预处理，然后就可以在debug里面发现又应该.i文件，点开后就可以发现这里已经被替换掉了。

#define Max(x,y) ((x)>(y)?(x):(y))
//      Max->宏的名字  
//         x和y->宏的参数
//                ((x)>(y)?(x):(y))->宏的内容

ps：在定义宏的内容的时候，最好每个参数都要加上小括号，然后最后整体加上小括号，否则如果传入参数不是单独一个值而是表达式的时候，会产生一些没有意料到的优先级计算改变

Tips：宏后面的参数的小括号一定要紧挨着宏的名

3.2.3 #define替换规则

1.先看宏的参数内是不是有define的符号，优先替换掉define符号

2.对于宏，参数名被他们的值替换

注意！！

1.宏的参数里可以出现其他#define定义的符号，但不可以递归

2.当define扫描预处理时，字符串常量的内容并不被搜索（也就是说字符串里面的东西是不会被宏预处理的）

3.2.4 #和##

#

相当于把宏的参数放进字符串中变成所对应的字符串

// #的用法
#define _CRT_SECURE_NO_WARNINGS 1
#define print(x) printf("the value of " #x " is %d\n",x)
#include <stdio.h>
int main()
{
    int a = 5;
    int b = 4;
    print(a);
    print(b);
    return 0;
}

##

可以把两边分离片段合成一个符号

#define CAT(C,num) C##num
int main()
{
    int Class104=10000;
    printf("%d\n",CAT(Class,104));
    return 0;
}

3.2.5带副作用的宏参数

#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
    int a=3;
    int b=5;
    int m=MAX(a++,b++);//宏的参数是直接替换进去
    所以替换完之后为：
    int m=((a++)>(b++)?(a++):(b++));//会出现错误
    printf("%d\n",m);
    printf("%d %d\n",a,b);
    return 0;
}

3.2.6宏和函数对比

宏的优点：

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

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

宏的缺点：

1.每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。

2.宏是没法调试的。

3.宏由于类型无关，也就不够严谨。

4.宏可能会带来运算符优先级的问题，导致程容易出现错

可从以下方面比较宏与函数的区别：

• 代码长度——宏如果不是特别小的话，每一次使用的时候都要替换成宏的定义，可能会导致最终代码特别长，大幅增长程序长度，而函数每次都只调用那一段代码
• 执行速度——宏只需要执行一行的代码，而函数拥有调用函数，执行代码，返回参数这三步操作，所以相对来说会慢一些
• 操作符优先级——由于宏是不经过计算直接将参数传进去的，所以在传参后可能会有优先级的不同导致结果与我们想要的最终结果有出入，除非加上括号。相对的函数参数只在函数调用的时候求值一次，会比较容易猜测结果。
• 带有副作用的参数——参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果。函数参数只在传参的时候求值一次，结果更容易控制。
• 参数类型——宏的参数类型相对自由，只要对参数的操作合法，就可以任何只要符合规定的参数类型。函数的参数类型是固定死的。
• 调试——宏不方便调试。函数能够调试。
• 递归——宏不能够递归，而函数可以递归

3.2.7 命名的约定

一般来讲宏与函数的使用语法很类似，所以以后使用这种方法区分宏与函数：

• 宏名全部大写
• 函数名不要全部大写（可开头或部分大写）

3.3 undef

去除一个宏定义

#undef 宏名

3.4命令行定义

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

#include <stdio.h>
int main()
{
    int array [SZ];
    int i = 0;
    for(i = 0; i< SZ; i ++)
   {
        array[i] = i;
   }
    for(i = 0; i< SZ; i ++)
   {
        printf("%d " ,array[i]);
   }
    printf("\n" );
    return 0;
}
 

在这里我们可以知道SZ这个符号始终没有被定义，到这里为止我们的程序还是无法运行的，会报错，但是：

编译指令：

//linux 环境演示
gcc -D SZ=10 programe.c

在编译完这一行以后程序就能够执行了，这是因为我们在命令行中已经将SZ这个符号定义好了。

3.5 条件编译

有一段代码，编译了麻烦，删去了可惜，这时可以选择是否编译，这时候就要用到条件编译。

应用场景：当我们使用在不同系统时，比如在用到windows系统时我们需要用到这一段代码，而在Linus系统上又要用到另一段代码而不能用windows那段代码的时候，不可以删除，因为要实现一个程序的跨平台使用，这时候就需要用到条件编译来选择什么时候使用哪段代码。

Tips：我们要明确条件编译指令也是预处理指令

//条件编译
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
    int i = 0;
    for (i = 0; i < 10; i++)
    {
#if 1 //这里的常量非0，于是执行,如果为0，则不执行
        printf("%d\n", i);
#endif
        return 0;
    }
}

不能放变量，因为是预处理阶段执行的，而变量在预处理中还没有出现，所以我们只能放常量进去，否则放变量进去的话只能判定为0。

常见的条件编译指令：

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

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

3.判断是否被定义：只要你定义了宏就为真

• #if defined(宏名) ...#endif #ifdef 宏名 ... #endif
• 如果要做到的是没有定义，则在前面加上！

#if !defined(宏名) ...#endif             #ifdef !宏名 ... #endif

4.嵌套指令

//全部类型的条件编译
#define _CRT_SECURE_NO_WARNINGS 1
#define VALUE 200
#define TEST 20
#include <stdio.h>
int main()
{
    int i = 0;
    for (i = 0; i < 10; i++)
    {
#if 1
        printf("%d\n", i);
#endif
    }
#if VALUE<100
    printf("value<100\n");
#elif VALUE>=100&&VALUE<=150
    printf("value>=100且value<=150\n");
#else
    printf("value>150\n");
#endif
#ifdef VALUE
    printf("VALUE已定义\n");
#else
    printf("VALUE未定义\n");
#endif
#if defined(VALUES)
    printf("VALUES已定义\n");
#else
    printf("VALUES未定义\n");
#endif
    //嵌套指令
#if VALUE<=150
#if defined(VALUE)
    printf("VALUE小于或等于150，VALUE已定义\n");
#else
    printf("VALUE小于或等于150，VALUE未定义\n");
#endif
#elif VALUE>150&&VALUE<=200
#ifdef TEST
    printf("VALUE大于150且小于等于200，TEST已定义\n");
#else
    printf("VALUE大于150且小于等于200，TEST未定义\n");
#endif
#endif
    return 0;
}

3.6文件包含

我们知道在预编译时会包含头文件，而头文件例如<stdio.h>从预编译.i文件上看我们可以知道有2000多行代码，若真的重复包含了五六次，则代码量直接上升到了一万多行，这时候就会使得代码过于冗长，同时也占用很多内存，这个时候我们就需要文件包含来确认是否重复包含了同一个头文件。

方法一：

//在头文件中
#ifndef __TEST_H__
#define __TEST_H__
int Add(int x,int y);
#endif

方法二：

//在头文件中
#pragma once
int Add(int x,int y);
 

ps：这个#pragma once是比较高级的写法，在远古编译器里面是无法使用的（如vc）

3.6.1头文件被包含的方式

在小绿本人之前的三子棋以及扫雷的博客中都有自己创造头文件而我们在引用自己创造的头文件时是以#include "fun.h" 这样的形式引用的，但是在引用库函数时确实以#include <stdio.h>的方式引用，那么用不同的符号引用头文件有什么不一样呢？

""的查找策略

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

<>的查找策略

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

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注编程网的更多内容!