15.程序环境和预处理【C语言】

最新推荐文章于 2022-11-10 01:06:30 发布
最新推荐文章于 2022-11-10 01:06:30 发布
阅读量227 收藏
点赞数
分类专栏： C 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2076188013/article/details/123184518
版权

image-20220225170844127

每一个源文件都会被编译成.obj文件，最后所有的.obj文件+链接库链接在一起生成可执行程序

1.翻译环境&运行环境

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

  1. 翻译环境，在这个环境中源代码被转换为可执行的机器指令。

  2. 是执行环境，用于实际执行代码。

2.过程详解

//Linux 环境下 Add.c文件
int Add(int x, int y)
{
    return x + y;
}


//Linux 环境下 test.c文件
#include <stdio.h>
extern int Add(int x, int y);
#define MAX 100
int main()
{
    int m = MAX;
    int a = 10;
    int b = 20;
    int c = 0;
    c = Add(a, b);
    printf("%d\n",c);
    return 0;
}

预编译

gcc -E test.c预编译test.c，并直接将结果输出到屏幕
gcc -E test.c -o test.i将编译好的结果输出到test.i文件里面
vim test.i 通过vim打开test.i 发现test.i有800多行，其实就是把头文件展开了

预编译（预处理）：做的都是文本操作

  1. 头文件展开
  2. 删除注释
  3. #define定义符号的替换，替换完之后删除#define

编译

gcc -S test.i生成了test.s文件，里面都是汇编代码

把C语言代码转换成汇编代码：

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

《编译原理》

《程序员的自我修养》

汇编

gcc -c test.c生成了test.o文件（Linux环境）（Windows环境下是.obj）
.o文件是二进制文件

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

形成符号表

test.c文件中，记录了Add main （记录自己的东西，不关系库里面的）

Add.c文件中，记录了Add

image-20220225174353586

由于test.c中Add只有声明没有定义，因此找不到Add的地址，就给他一个没有意义的填充值

.o文件的文件格式是elf，可以用readelf工具解析elf格式的文件
readelf -s test.o-s表示只显示里面的符号

链接

gcc add.o test.o -o test指定生成文件名为test
test其实就是可执行程序

gcc add.o test.o默认生成的a.out

链接时：

  1. 合并段表
  2. 符号表的合并和重定位
    重新计算各个目标的地址过程叫做重定位

多个目标文件进行链接的时候就会通过符号表查看来自外部的符号是否真实存在
这也是函数没声明也能运行的原因

3.运行环境

程序执行的过程：

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

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

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

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

4.详解预处理

预定义符号

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

int main(int argc, char const *argv[])
{
    printf("%s\n",__FILE__);//D:\code\2022code\Cpp_Code\2-22-Class&object 02\src\test.cpp
    system("pause");
    return 0;
}

日志记录

int main(int argc, char const *argv[])
{
    //记录日志
    FILE *pf = fopen("log.txt", "w");
    if (pf == nullptr)
    {
        printf("fopen fail\n");
        return 1;
    }
    for (int i = 0; i < 10; i++)
    {
        fprintf(pf, "%s %s %s %d %d\n", __DATE__, __TIME__, __LINE__, __FILE__, i);
    }
    fclose(pf);
    pf = nullptr;
    system("pause");
    return 0;
}

#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\tdate:%s\ttime:%s\n", __FILE__, __LINE__, __DATE__, __TIME__)

在define定义标识符的时候不能加；不然会语法错误

定义宏

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

#define name( parament-list ) stuff

#define SQUARE(x)  ((x) * (x))
//宏最好每个表达式都加上()
#define MAX(x,y) ((x)>(y))?(x):(y)//防止如果传MAX(a+2,b)造成干扰
int main()
{
    int a = 10;
    int b = 20;
    int m = MAX(a,b)
    printf("%d\n",m);
    return 0;
}

替换规则

  1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

  2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

  3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意：

  1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

  2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

#define M 10
#define N 10
printf("M+N:");//这里是字符串里面的，不会被替换

# & ##

如何把参数插入到字符串中？

char* p = "hello ""bit\n";
printf("hello"," bit\n");
printf("%s", p);
//结果都是hello bit
//字符串是有自动连接的特点

#define PRINT(n) printf("the value of "#n" is %d\n",n)
int main(int argc, char const *argv[])
{
    int a = 10;
    int b = 20;
    PRINT(a);//the value of a is 10
    PRINT(b);//the value of b is 20
    system("pause");
    return 0;
}
//#n 替换过去之后就变成了"n"
//"the value of ""n"" is %d\n"

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

#define CAT(c,num) c##num
int main(int argc, char const *argv[])
{
    int Class104 = 10000;
    printf("%d\n",CAT(Class,104));//Class104  10000
    system("pause");
    return 0;
}

带副作用的宏参数

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

int main(int argc, char const *argv[])
{
    getchar();//读取一个字符同时就会拿走那个字符
    fgetc();
    int a = 2;
    int b = ++a; // b=3,a=3  副作用
    int c = a + 1;//b=3,a=2  无副作用
    system("pause");
    return 0;
}

#define MAX(x,y) ((x)>(y))?(x):(y)
int main(int argc, char const *argv[])
{
    int a = 3;
    int b = 5;
    int m = MAX(a++,b++);
    //实际上是直接把a++，b++替换进去的
    //int m = ((a++)>(b++))?(a++):(b++)
    printf("%d\n",m);//6
    printf("%d %d\n",a,b);//4 7
    system("pause");
    return 0;
}

宏和函数

为什么不用函数完成GetMax？

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

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

宏的缺点

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

  2. 宏是没法调试的。

  3. 宏由于类型无关，也就不够严谨。 比特就业课-专注IT大学生就业的精品课程

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

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

#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main(int argc, char const *argv[])
{
    int* p2 = MALLOC(10,int);//函数的参数可不能传类型，宏才可以
    system("pause");
    return 0;
}
//但还是不推荐，因为代码可读性变差
属性#define定义宏函数
代码长度每次使用时，宏代码都会被插入到程序中。除了非常小的宏之外，程序的长度会大幅度增长函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码
执行速度更快。存在函数的调用和返回的额外开销，所以相对慢一些
操作符优先级宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多些括号。函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测。
带有副作用的参数参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果。函数参数只在传参的时候求值一次，结果更容易控制。
参数类型任意类型均可。函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是不同的。
调试不方便调试可以逐语句调试
递归不能递归可以递归

命名约定

把宏名全部大写

函数名不要全部大写

#undef

移除一个宏指令

#define MAX(x,y) ((x)>(y))?(x):(y)
int main(int argc, char const *argv[])
{
#undef MAX
    int a = 3;
    int b = 5;
    int m = MAX(a,b);//err 不能用了
    printf("%d\n",m);
    system("pause");
    return 0;
}

命令行定义

许多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; 
}

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

条件编译

#include <stdio.h>
int main()
{
    int i = 0;
    int arr[10] = {0};
    for (i = 0; i < 10; i++)
    {
        arr[i] = i;

#if 1//#if 后面不能+变量 因为这些都是预处理时完成的，那时变量都还没初始化
        printf("%d\n", arr[i]); //为了观察数组是否赋值成功。
#endif                          
    }
    system("pause");
    return 0;
}

常见的条件编译指令

1.
#if 常量表达式
//...
#endif
    //常量表达式由预处理器求值。
    如：
#define __DEBUG__ 1
#if __DEBUG__
//..
#endif
   
2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif

3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#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 <stdio.h>
#define M 0
int main()
{
#if defined(M)
    printf("hehe\n");
#endif

#ifdef M
    printf("haha\n");
#endif

#if !defined(M)
    printf("heihei\n");
#endif

#ifndef M
    printf("huihui\n");
#endif
    system("pause");
    return 0;
}
//hehe
//haha

文件包含

防止头文件重复包含

//.h文件中
#ifndef __TEST_H__
#define __TEST_H__
int Add(int x, int y);
#endif
//早期写法

//.h文件中
#pragma once
int Add(int x, int y);

包含方式

  1. 本地文件包含
#include "filename"

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

如果找不到就提示编译错误。

  1. 库文件包含
#include <filename.h>

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

练习

交换二进制奇偶位

// 10
// 00000000000000000000000000001010  -10
// 01010101010101010101010101010101  按位与就能保留所有的奇数位，偶数位置0
// 0x55555555
// 01010101010101010101010101010101  按位与就能保留所有的偶数位，奇数位置0，
// 0xAAAAAAAA
//分别<< >> 即可，二者再相加即可
#define SWAPODDEVEN(x) ((x) = (((x & 0x55555555) << 1) + ((x & 0xAAAAAAAA) >> 1)))
int main(int argc, char const *argv[])
{
    int x = 10;
    SWAPODDEVEN(x);
    printf("%d\n", x);
    system("pause");
    return 0;
}

offsetof宏的实现

#include <stddef.h>
#include <stdio.h>  
struct S
{
    char c;
    int a;
    double d;
};

//计算结构体中某变量相对于首地址的偏移
int main(int argc, char const *argv[])
{
    struct S s = {0};
    printf("%d\n",offsetof(struct S, c));//0
    printf("%d\n",offsetof(struct S, a));//4
    printf("%d\n",offsetof(struct S, d));//8
    system("pause");
    return 0;
}

#include <stddef.h>
#include <stdio.h>  
struct S
{
    char c;
    int a;
    double d;
};

//计算结构体中某变量相对于首地址的偏移
#define OFFSETOF(sName, mName) (int)&(((sName*)0)->mName)
int main(int argc, char const *argv[])
{
    struct S s = {0};
    printf("%d\n",OFFSETOF(struct S, c));//0
    printf("%d\n",offsetof(struct S, c));//0
    printf("%d\n",OFFSETOF(struct S, a));//4
    printf("%d\n",offsetof(struct S, a));//4
    printf("%d\n",OFFSETOF(struct S, d));//8
    printf("%d\n",offsetof(struct S, d));//8
    system("pause");
    return 0;
}
TauCeti0207
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在c语言中预处理命令行都以井号开头,以井号开头的行和gcc预处理器输出中的'＃1“ac”'之类的数字是什么意思？...
weixin_39948309的博客
05-25 1286
以井号开头的行和gcc预处理器输出中的'＃1“ac”'之类的数字是什么意思？我使用打印出C预处理器的输出gcc -E a.c输出包含许多行# 1 "a.c"# 1 ""# 1 ""# 1 "a.c"# 1 "c:\\mingw\\bin\\../lib/gcc/mingw32/4.5.0/../../../../include/stdio.h" 1 3# 19 "c:\\mingw\\bin\\....
C学习笔记-gcc
weixin_30591551的博客
04-02 125
GNU CC(通常称为GCC)是GNU项目的编译器，它能够编译C、C++语言编写的程序 gcc的优点 使用gcc，程序员可以控制生成二进制执行文件中调试代码的数量和类型。 和其他编译器一样，gcc也可以优化执行代码。 gcc是个交叉平台编译器，所以能够在当前CPU平台上为不同操作系统开发软件。 gcc对C和C++进行了一些扩展，有助于...
gcc编译的第一步---预处理
qq_54075859的博客
08-06 1344
gcc编译的第一步预处理； 头文件包含 ；宏替换 ，预定义宏，带参宏，不带参宏 ；条件编译，#ifdef ，#ifndef，#if
gcc 参数_gcc预处理及printf()格式化输出!
weixin_39737051的博客
11-27 1039
一、main()函数种类：main函数标准类型无参：int main(void) { return 0; }有参：int main(int argc, *argv[]) { return 0; }main()函数其他基本类型//都能正常运行，但是不是main()的标准语句void main(int argc, char *argv[]);void main(void);int main();int...
[C语言程序设计(第四版)].谭浩强.高清_C语言程序设计第四版_
10-02
总的来说，《C语言程序设计（第四版）》不仅涵盖了C语言的基础知识，还包括了许多实用技巧和编程经验。通过系统学习这本书，初学者可以建立起坚实的C语言基础，为后续的软件开发或系统编程打下坚实的基础。
C语言程序设计.--预处理
12-20
在C语言中，预处理是编译过程的第一步，它主要负责处理源代码中的预处理命令，这些命令以`#`开头。预处理命令的作用在于扩展宏定义、包含头文件以及...理解并熟练使用预处理命令是编写高效、可维护C语言程序的基础。
杨辉三角C语言程序源码.zip
最新发布
11-16
首先，我们要知道C语言程序的基本结构，包括预处理指令、函数定义、变量声明和控制结构（如for、while、if-else）。在这个程序中，我们可能会看到一个主函数`main()`，它是程序执行的起点。 程序的核心部分是生成...
c语言程序设计教程答案.pdf
06-23
5. **快捷键和操作**：文件保存可使用F2键或File菜单的Save选项，F10调用主菜单，F4运行到光标行，Ctrl+F9编译、链接并运行程序，Alt+F5在DOS环境下查看运行结果。 6. **输出与输入示例**：涉及字符串处理、格式化...
预处理（JAVA实现C语言预处理程序）.zip
12-22
总的来说，这个"预处理（JAVA实现C语言预处理程序）"项目为学习编译原理的人员提供了一个实用的工具，帮助他们理解和实现C语言预处理的核心功能。虽然它可能没有涵盖所有预处理的复杂特性，但对于初学者来说，这是一...
linux下用gcc如何生成预处理、汇编等文件
weixin_30535913的博客
12-02 603
【gcc -E test.c -o test.i------>预处理文件生成.i 文件。】 1、c语言程序生成过程 C语言程序的生成过程可以简单的分为：编辑、预处理、编译、汇编、链接五个阶断。 下面所有的操作以hello world程序为例，源码文件命名为t.c，源码内容如下： #include <stdio.h> int ma...
c程序从源代码到目标程序的过程需要那些步骤
xiezhongtian的专栏
07-26 2870
在Linux下进行C语言编程，必然要采用GNU GCC来编译C源代码生成可执行程序。 一、GCC快速入门 Gcc指令的一般格式为：Gcc [选项] 要编译的文件 [选项] [目标文件] 其中，目标文件可缺省，Gcc默认生成可执行的文件名为：a.out 然后输入./a.out 便可运行得到结果 我们来看一下经典入门程序"Hello World！" # vi hello.c #i
linux gcc 怎么只预处理，不编译链接等
李子的备忘录
10-28 4146
由于一些特殊的目的，只需要预处理 如： 检查某些宏定义，是否正确等 。 gcc  --help 输出：-E                       Preprocess only; do not compile, assemble or link                                        仅仅预处理，不编译，汇编或链接  gcc -E ./main
Linux（Ubuntu）操作系统，vi编辑器与gcc编译器的下载与使用（命令参数很详细）
qq_57663276的博客
11-10 6639
Linux（Ubuntu）操作系统，六：vi编辑器与gcc编译器使用
Gcc 编译的背后--预处理
化茧成蝶007
08-25 519
预处理 简述 预处理是 C 语言程序从源代码变成可执行程序的第一步，主要是 C 语言编译器对各种预处理命令进行处理，包括头文件的包含、宏定义的扩展、条件编译的选择等。 以前没怎么“深入”预处理，脑子对这些东西总是很模糊，只记得在编译的基本过程（词法分析、语法分析）之前还需要对源代码中的宏定义、文件包含、条件编译等命令进行处理。这三类的指令很常见，主要有 #define，#incl
【Linux编程】如何使用gcc生成预编译文件？
热门推荐
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
12-10 2万+
如何在Linux下使用GCC编译生成预处理文件？
查看 gcc/g++ 预编译结果
yasi_xi的专栏
08-04 7256
转自：《程序员的自我修养——链接、装载与库》第39页 今天看到《链接、装载与库》第39页时，看到一个很有用的知识点，记录下来。 以前使用一些框架，比如gtest时，里面的宏定义的比较复杂，使用时总觉得看不清真面目，也就是说不知道使用了其中的宏，最终展开成什么样子。下面是一个解决办法： 以下面的m.cpp为例说明。 #define FOO_ADD(a, b) (a + b
gcc——预处理（预编译），编译，汇编，链接
huoyahuoya的博客
11-08 1万+
一，预编译 操作步骤：gcc -E hello.c -o hello.i 主要作用： 处理关于 “#” 的指令 【1】删除#define，展开所有宏定义。例#define portnumber 3333 【2】处理条件预编译 #if, #ifdef, #if, #elif,#endif 【3】处理“#include”预编译指令，将包含的“.h”文件插入对应位置。这可是递归进行的，文件内
《C语言程序设计-现代方法》 笔记
weixin_41368627的博客
05-31 2493
本篇笔记参考了《C语言程序设计-现代方法》和浙大翁恺的C语言视频。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值