文章目录

一.程序翻译环境和执行环境
- 1.ANSI C 标准
- 2.程序的翻译环境和执行环境
二.程序编译和链接
- 1.翻译环境
- 2.编译本身的几个阶段
- 3.运行环境
三.预处理
- 1.预定义符号
- 2.#define
- - （1）#define定义标识符
  - （2）#define定义宏
  - （3）#define替换规则
- 3.#和##
- - （1）#
  - （2）##
- 4.#undef
- 5.带"副作用"的宏参数
- 6.宏和函数对比
- 7.命名约定
四.命令行编译
五.条件编译
- 1.条件编译常量表达式
- 2.多分支的条件编译
- 3.条件编译是否被定义
- 4.条件编译的嵌套
六.文件包含
- 1.头文件被包含的方式
- 2.嵌套文件的包含

一.程序翻译环境和执行环境

1.ANSI C 标准

ANSI C是由美国国家标准协会（ANSI）及国际化标准组织（ISO）推出的关于C语言的标准。ANSI C 主要标准化了现存的实现，同时增加了一些来自 C++ 的内容（主要是函数原型）并支持多国字符集（包括备受争议的三字符序列）。
ANSI C 几乎被所有广泛使用的编译器所支持，且多数C代码是在ANSI C基础上写的。

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

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

翻译环境：在该环境中，源代码被转换为可执行的机器指令。
执行环境：用于实际执行代码。

二.程序编译和链接

1.翻译环境

在这里插入图片描述

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

举个例子：test.c、add.c、minu.c
在这里插入图片描述

2.编译本身的几个阶段

举个例子：
① sum.c

int global_val = 2021;
void print(const char* string) {
    printf("%s\n", string);
}

② test.c

#include <stdio.h>
 
int main(void) {
    extern void print(char* string);
    extern int global_val;
    printf("%d\n", global_val);
    printf("Hello,World!\n");
 
    return 0;
}

编译阶段为：
在这里插入图片描述
解析图如下：

3.运行环境

程序执行过程：

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

三.预处理

1.预定义符号

1.__FILE__			//进行变异的源文件
2.__LINE__			//文件当前的行号	
3.__DATE__			//文件被编译的日期
4.__TIME__			//文件被编译的时间
5.__STDC__			//如果编译器遵循ANSI C，其值为1，否则未定义
6.__FUNCTION__      //返回所在函数的函数名

在预处理阶段被处理的已经定义好的符号为预定义符号。这些符号是可以直接使用的，是在C语言中已经内置好的。

注意：值得注意的是，__ 为两个下划线！
用法演示：

#include <stdio.h>
 
int main(void) {
    printf("%s\n", __FILE__);     // 返回使用行代码所在的源文件名，包括路径
    printf("%d\n", __LINE__);     // 返回行号
    printf("%s\n", __DATE__);     // 返回程序被编译的日期
    printf("%s\n", __TIME__);     // 返回程序被编译的时间
    printf("%s\n", __FUNCTION__); // 返回所在函数的函数名
 
    return 0;
}

运行结果：
在这里插入图片描述

那么这些预定义符号有什么用？

如果一个工程特别复杂，这时去调试时可能会无从下手。所以需要代码在运行的过程中记录一些日志信息，通过日志信息分析程序哪里出了问题，再进行排查就如同瓮中捉鳖。

2.#define

（1）#define定义标识符

#define NAME stuff

用法演示：

#include <stdio.h>
 
#define TIMES 100
 
int main(void) {
    int t = TIMES;
    printf("%d\n", t);
 
    return 0;
}

运行结果：100
在预处理阶段会把 TIMES 替换为 100。预处理结束后 int t = TIMES 就没有TIMES 了，会变为 int t = 100。

// 预处理前
int t = TIMES;
// 预处理后
int t = 100;

当然了， #define 定义的符号可不仅仅只有数字，还可以用来做很多事，比如：

1.#define REG register        //给关键字register，创建一个简短的名字
2.#define DEAD_LOOP for(;;)   //用更形象的符号来替换一种实现

① #define REG register，给关键字 register，创建一个简短的名字：

#define REG register
 
int main(void) {
    register int num = 0;
    REG int num = 0; // 这里REG就等于register
 
    return 0;
}

② #define DEAD_LOOP for(;;），用更形象的符号来替换一种实现：

#define DEAD_LOOP for(;;)
 
int main(void) {
    DEAD_LOOP // 预处理后替换为 for(;;); 
        ; // 循环体循环的是一条空语句
 
    DEAD_LOOP; // 那么可以这么写，这个分号就是循环体，循环的是一个空语句
 
    return 0;
}

③ #define CASE break;case ，在写case语句的时候自动字上break（很巧妙的偷懒）：

#define CASE break;case     // 在写case语句的时候自动字上break
 
int main(void) {
    int n = 0;
    //switch (n) {
    //    case 1:
    //        break;
    //    case 2:
    //        break;
    //    case 3:
    //        break;
    //}
 
    switch (n) {
        case 1: // 第一个case不能替换
        CASE 2: // 相当于 break; case 2:
        CASE 3: // 相当于 break; case 3:
    }
 
    return 0;
}

有个细节，再前面 #define 定义标识符时，为什么末尾没有加上分号呢？

#define TIMES 100;
#define TIMES 100

这是因为，分号也会被当作替换内容替换到文本当中，可能会导致出现错误：

#define _CRT_SECURE_NO_WARNINGS 1
 
#include <stdio.h>
 
#define TIMES 100;
 
int main(void) {
    int a, b;
    if (a > 10)
        b = TIMES; // b = 100;;
    else //else没有匹配对象
        b = -TIMES; // b = 100;;
 
    return 0;
}

所以，在 #define 定义标识符时，尽量不要在末尾加分号！（必须加的情况除外）

（2）#define定义宏

#define NAME(parament-list) stuff

#define 机制允许把参数替换到文本中，这种实现通常被称为宏（macro）或定义宏（define macro），parament-list 是一个由逗号隔开的符号表，他们可能出现在 stuff 中。

注意：

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

用法演示：3*3=9

#include <stdio.h>
 
#define SQUARE(X) X*X
 
int main(void) {
    printf("%d\n", SQUARE(3)); // printf("%d\n", 3 * 3);
 
    return 0;
}

那么，(3+1) 的结果是什么？

#include <stdio.h>
 
#define SQUARE(X) X*X
 
int main(void) {
    printf("%d\n", SQUARE(3+1));
 
    return 0;
}

运行结果：7

这是因为替换是在预处理阶段时替换，表达式真正计算出结果是在运行时计算。所以先替换：
3+1*3+1=7

如果想获得 3+1 相乘（也就是得到 4×4 = 16）的结果，我们需要给他们添加括号：

#include <stdio.h>
 
// 整体再括一个括号，严谨
#define SQUARE(X) ((X)*(X))
 
int main(void) {
    printf("%d\n", SQUARE(3+1));
 
    return 0;
}

另外，整体再套一个括号！让代码更加严谨，防止产生不必要的错误。比如，，我希望得到 10* DOUBLE，可能会得到以下情况：

#include <stdio.h>
 
#define DOUBLE(X) (X)+(X)
 
int main(void) {
    printf("%d\n", 10 * DOUBLE(3+1));
    // printf("%d\n", 10 * (4) + (4)); 
    // 我们本意是想得到80，但是结果为44，因为整体没带括号
 
    return 0;
}

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

（3）#define替换规则

在程序中扩展 #define 定义符号或宏时，需要涉及的步骤如下：

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

注意事项：

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

3.#和##

我们知道，宏是把参数替换到文本中。那么如何把参数插入到字符串中呢？
比如这种情况，使用函数是根本做不到的：

void print(int x) {
    printf("变量？的值是%d\n", ？) 函数根本做不到
}
 
int main(void) {
    int a = 10;
    // 打印内容：变量a的值是10
    print(a);
 
    int b = 20;
    // 打印内容：变量b的值是20
    print(b);
 
    int c = 30;
    // 打印内容：变量c的值是30
    print(c);
 
    return 0;
}

这种情况，就可以用宏来实现。

（1）#

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

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

使用 # 解决上面的问题：

#include <stdio.h>
#define PRINT(X) printf("变量"#X"的值是%d\n", X);
// #X 就会变成 X内容所定义的字符串
 
int main(void) {
    // 打印内容：变量a的值是10
    int a = 10;
    PRINT(a); // printf("变量""a""的值是%d\n", a);
 
    // 打印内容：变量b的值是20
    int b = 20;
    PRINT(b); // printf("变量""b"的值是%d\n", b);
 
    // 打印内容：变量c的值是30
    int c = 30;
    PRINT(c); // printf("变量""c""的值是%d\n", c);
 
    return 0;
}

运行结果：
在这里插入图片描述

改进：让程序不仅仅支持打印整数，还可以打印其他类型的数（比如浮点数）：

#include <stdio.h>
#define PRINT(X, FORMAT) printf("变量"#X"的值是 "FORMAT"\n", X);
 
int main(void) {
    // 打印内容：变量a的值是10
    int a = 10;
    PRINT(a, "%d");
 
    // 打印内容：变量f的值是5.5
    float f = 5.5f;
    PRINT(f, "%.1f"); //printf("变量""f""的值是 ""%.1f""\n", f);
 
    return 0;
}

运行结果：
在这里插入图片描述

（2）##

##   //把位于它两边的符号合并成一个符号

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

用法演示：

#include <stdio.h>
 
#define CAT(X,Y) X##Y
 
int main(void) {
    int vs2003 = 100;
 
    printf("%d\n", CAT(vs, 2003)); // printf("%d\n", vs2003);
 
    return 0;
}

运行结果：
在这里插入图片描述
##也可以将多个符号合成一个符号，比如 X##Y##Z

4.#undef

#undef NAME	   //移除一个宏定义

用于移除一个宏定义。

用法演示：用完 M 之后移除该定义

#include <stdio.h>
 
#define M 100
 
int main(void) {
    int a = M;
    printf("%d\n", M);
#undef M // 移除宏定义
 
    return 0;
}

5.带"副作用"的宏参数

什么是副作用？
副作用就是表达式求值的时候出现的永久性效果，例如：

//不带有副作用
x + 1;
//带有副作用
x++;  
 
int a = 1;
//不带有副作用
int b = a + 1; //b=2, a=1
//带有副作用
int b = ++a;  //b=2, a=2

当宏参数在宏的定义中出现超过一次的情况下，如果参数带有副作用，那么在使用这个宏的时候就可能出现危险，导致不可预料的后果。这种带有副作用的宏参数如果传到宏体内，这种副作用会一直延续到宏体内。

举个例子：

#include <stdio.h>
 
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
 
int main(void) {
    int a = 5;
    int b = 8;
    int m = MAX(a++, b++);
 
    printf("m = %d\n", m);
    printf("a=%d, b=%d\n", a, b);
 
    return 0;
}

运行结果：
在这里插入图片描述

所以，写宏的时候尽量避免使用这种带副作用的参数。

6.宏和函数对比

举个例子：在两数中找较大值
① 用宏：

#include <stdio.h>
 
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
 
int main(void) {
    int a = 10;
    int b = 20;
    int m = MAX(a, b); // int m = ((a)>(b) ? (a):(b))
    printf("%d\n", m);
    
    return 0;
}

② 用函数：

#include <stdio.h>
 
int Max(int x, int y) {
    return x > y ? x : y;
}
 
int main(void) {
    int a = 10;
    int b = 20;
    int m = Max(a, b);
    printf("%d\n", m);
 
    return 0;
}

那么，宏和函数那种更好呢？

答案是宏

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

当然，宏也有劣势的地方：

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

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

#include <stdio.h>
#include <stdlib.h>
 
#define MALLOC(num, type) (type*)malloc(num*sizeof(type))
 
int main(void) {
    // 原本的写法：malloc(10*sizeof(int));
    // 但我想这么写：malloc(10, int);
 
    int* p = MALLOC(10, int); // (int*)malloc(10*sizeof(int))
 
    ...
    
    return 0;    
}

所以，如果一个运算的逻辑足够简单，建议使用宏。反之，如果一个运算的逻辑足够复杂，建议使用函数。

7.命名约定

命名约定，一般来讲函数的宏的使用语法很相似，所以语言本身没法帮我们区分二者。约定俗成的一个习惯是：宏名全部大写，函数名不要全部大写。

四.命令行编译

什么是命令行编译？

在编译的时候通过命令行的方式对其进行相关的定义，叫做命令行编译。

许多C的编译器提供的一种能力，允许在命令行中定义符号。用于启动编译过程。当我们根据同一个源文件要编译出不同的一个程序的不同版本的时，可以用到这种特性，增加灵活性。

比如：假如某个程序中声明了一个某个长度的数组，假如机器甲内存有限，我们需要一个很小的数据，但是机器丙的内存较大，我们需要一个大点的数组。

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

gcc 环境下测试：（VS 里面不太好演示）
gcc -D ARRAY_SIZE=10 programe.c

五.条件编译

在编译一个程序时，通过条件编译指令将一条语句（一组语句）编译或者放弃是很方便的。

调试用的代码删除了可惜，保留了又碍事。我们就可以使用条件编译来选择性地编译：

#include <stdio.h>
 
#define __DEBUG__ // 就像一个开关一样
 
int main(void)
{
    int arr[10] = {0};
    int i = 0;
    for (i = 0; i < 10; i++) {
        arr[i] = i;
        #ifdef __DEBUG__ // 因为__DEBUG__被定义了，所以为真
        printf("%d ", arr[i]); // 就打印数组    
        #endif // 包尾
    }
 
    return 0;
}

运行结果：1 2 3 4 5 6 7 8 9 10

如果不想用了，就把 #define DEBUG 注释掉：

#include <stdio.h>
 
// #define __DEBUG__ // 关
 
int main(void)
{
    int arr[10] = {0};
    int i = 0;
    for (i = 0; i < 10; i++) {
        arr[i] = i;
        #ifdef __DEBUG__ // 此时ifdef为假
        printf("%d ", arr[i]);      
        #endif
    }
 
    return 0;
}

1.条件编译常量表达式

#if 常量表达式
   ……
#endif

如果常量表达式为真，参加编译。反之如果为假，则不参加编译。

用法演示：常量表达式为真

#include <stdio.h>
 
int main(void) {
#if 1
    printf("Hello,World!\n");
#endif
 
    return 0;
}

2.多分支的条件编译

#if 常量表达式
   ……
#else if 常量表达式
   ……
#else
   ……
#endif

多分支的条件编译，直到常量表达式为真时才执行。

用法演示：

#include <stdio.h>
 
int main(void) {
#if 1 == 2 // 假
    printf("rose\n");
#elif 2 == 2 // 真
    printf("you jump\n");
#else 
    printf("i jump\n")
#endif
 
    return 0;
}

运行结果：you jump

3.条件编译是否被定义

#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

ifdef 和 if defined() ，ifndef 和 if !defined() 效果是一样的，用来判断是否被定义。

用法演示：

#include <stdio.h>
 
#define TEST 0
// #define TEST2 // 不定义
 
int main(void) {
/* 如果TEST定义了，下面参与编译 */
// 1
#ifdef TEST
    printf("1\n");
#endif
 
// 2
#if defined(TEST)
    printf("2\n");
#endif
 
 
/* 如果TEST2不定义，下面参与编译 */
// 1
#ifndef TEST2
    printf("3\n");
#endif
 
// 2
#if !defined(TEST2)
    printf("4\n");
#endif
 
    return 0;
}

运行结果：
在这里插入图片描述

4.条件编译的嵌套

和 if 语句一样，是可以嵌套的：

#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次。

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

还有一种非常简单的方法：

#pragma once // 让头文件即使被包含多次，也只编译一份

—————————————————————————————————
本篇到此结束，码文不易，还请多多支持！

十五.程序环境和预处理

文章目录

一.程序翻译环境和执行环境

1.ANSI C 标准

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

二.程序编译和链接

1.翻译环境

2.编译本身的几个阶段

3.运行环境

三.预处理

1.预定义符号

2.#define

（1）#define定义标识符

（2）#define定义宏

（3）#define替换规则

3.#和##

（1）#

（2）##

4.#undef

5.带"副作用"的宏参数

6.宏和函数对比

7.命名约定

四.命令行编译

五.条件编译

1.条件编译常量表达式

2.多分支的条件编译

3.条件编译是否被定义

4.条件编译的嵌套

六.文件包含

1.头文件被包含的方式

2.嵌套文件的包含

相关文章