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

最新推荐文章于 2024-07-06 15:15:17 发布
最新推荐文章于 2024-07-06 15:15:17 发布
阅读量845 收藏 21
点赞数 29
分类专栏： C语言 文章标签： c语言 java 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_85096248/article/details/139400994
版权
❤️欢迎来到我的博客❤️

这里是目录

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

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

第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令（二进制指令）
第2种是执行环境，它用于实际执行代码
翻译环境 - 把test.c的源代码经过翻译环境处理生成test.exe的文件。VS就是充当了一个翻译环境

编译过程：
在这里插入图片描述

每个源文件都会单独经过编译器处理，会生成对应的目标文件（后缀为.obj）。
之后多个目标文件一起在加上链接库，通过链接库的链接，最后生成可执行程序。

在这里插入图片描述
预编译：

生成test.i文件

  1. #include 头文件的包含
  2. #deifne 定义符号的替换和删除
    比如：#define M 100这条指令，会被删除同时如果有int max = M；那么M会被替换成100。
  3. 注释的删除
    以上都为文本操作

编译：
生成test.s文件

把C语言代码翻译成汇编代码
翻译阶段会进行以下操作：

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

汇编：

生成test.obj文件（Windows下）/test.o（Linux下）(目标文件）

把汇编代码翻译成二进制指令（存放在目标文件中）
文件的格式是：elf 也就是段表。
生成符号表

链接：

  1. 合并段表
  2. 符号表的合并和重定位
  3. 生成可执行程序

运行环境

程序执行的过程：

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

预处理讲解

预定义符号

__ FILE__ //进行编译的源文件
__ LINE__ //文件当前的行号
__ DATE__ //文件被编译的日期
__ TIME__ //文件被编译的时间
__ STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义

例如：

#include <stdio.h>

int main()
{
	printf("%s\n", __TIME__);
	printf("%s\n", __DATE__);
	return 0;
}

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

#define定义标识符

语法：

#define name stuff

比如：

#define MAX 10000
#define reg register	  //为 register这个关键字，创建一个简短的名字(reg)
#define do_forever for(;;)//用更形象的符号来替换一种实现 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__ )

注：
在define定义标识符的时候建议不要加上 ; ,这样容易导致问题。

例如：

#define MAX 1000;

int main()
{
	int m = 0;
	if(m>= 0)
		m = MAX;
	else
		m = -1;
	printf("%d\n",m);
	return 0;
}

以上代码在编译时会替换成：


int main()
{
	int m = 0;
	if(m>= 0)
		m = 1000;;  //两个;为2条语句if需要加上{}那么这段代码就会出现问题
					//MAX会被替换成1000;
	else
		m = -1;
	printf("%d\n",m);
	return 0;
}

#define定义宏

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

宏的声明方式：

#define name( parament-list ) stuff
其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

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

比如：

#include <stdio.h>
#define SQUARE(x) x*x
//SQUARE - 宏的名字 
//x - 宏的参数 
//x*x - 宏的内容

int main()
{
	printf("%d\n", SQUARE(5));
	printf("%d\n", SQUARE(5));
	return 0;
}

这段代码在运行时会被替换为：

	printf("%d\n", 5 * 5);
	printf("%d\n", 5.0 * 5.0);

运行效果：
在这里插入图片描述
此代码会存在一定问题
例如：

#include <stdio.h>
#define SQUARE(x) x*x

int main()
{
	printf("%d\n", SQUARE(5 + 1));
	return 0;
}

此时我们想要的结果应该为：36
但实际的结果却为：11
为什么会是这个结果呢？因为宏是替换的，这段代码会被替换成：

	printf("%d\n", 5 + 1 * 5 + 1);//结果为11

那么怎么避免这种情况呢，解决方法如下：

	#define SQUARE(x) (x) * (x)//把两个x扩起来
	//这样替换后的结果就为：
	printf("%d\n", (5+1) * (5+1));//结果为36
	//如果我们希望算完的参数是个整体的话那就整体再带上一层括号：
	#define SQUARE(x) ((x) * (x))
	//可避免以下情况：
	printf("%d\n",10*SQUARE(3));
	//替换后：
	printf("%d\n",10*((3)+(3)));

#define替换规则

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

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

注意：

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

例如：

#define MAX(x,y) ((x) > (y) ? (x) : (y))
#define M 100

int main()
{
	int m = MAX(M, 3);
	return 0;
}

第一次替换：

	int m = MAX(100, 3);

第二次替换：

	int m = (100) > (3) ? (100) : (3);

#和##

#的作用
使用 # ，把一个宏参数变成对应的字符串。
如果我们要打印一个字符串可以怎样打印呢？

int main()
{
	printf("hello world\n");
	printf("hello ""world\n");
	//两种方法都可以打印hello world
	return 0;
}

我们来看下面这段代码：

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

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

这段代码的功能十分相似，那我们能不能把他写成宏呢？
实现方法：

#define PRINT(x) printf("the value of x is %d\n",x);

int main()
{
	int a = 10;
	PRINT(a);

	int b = 20;
	PRINT(b);

	return 0;
}

如果我们只是这样写的话代码会出现一个问题 —— 名字不会被改变
运行效果：
在这里插入图片描述
那么如何解决这个问题呢，很简单只需要x独立出来，再在前面加上#就可以解决：

#define PRINT(x) printf("the value of "#x" is %d\n",x);

int main()
{
	int a = 10;
	PRINT(a);

	int b = 20;
	PRINT(b);

	return 0;
}

运行效果：
在这里插入图片描述
可以看到，x已被替换。
#可以把宏的参数插入到字符串中。

指定格式打印：

#define PRINT(format,x) printf("the value of "#x" is "format"\n",x);

int main()
{
	int a = 10;
	PRINT("%d", a);
	//代码替换为：printf("the value of "a" is ""%d"\n",x);
	
	int b = 20;
	PRINT("%d",b);
	//代码替换为：printf("the value of "b" is ""%d"\n",x);
	
	float c = 3.14;
	PRINT("%f", c);
	//代码替换为：printf("the value of "c" is ""%f"\n",x);
	
	return 0;
}

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

##的作用

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

例如：

#define CAT(x,y) x##y
//替换后Class##11 == Class11
int main()
{
	int Class11 = 2023;
	printf("%d\n", CAT(Class, 11));

	return 0;
}

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

带有副作用的宏参数

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

x+1;//不带副作用
x++;//带有副作用（x的值变化了）

MAX宏可以证明具有副作用的参数所引起的问题。
以下这段代码在运行起来是没有任何问题的。

#include <stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))

int main()
{
    int m = MAX(6, 3);
    printf("%d\n", m);
    return 0;
}

那如果我们这样去写：

#include <stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))

int main()
{
    int a = 4;
    int b = 6;
    int m = MAX(a++, b++);
    printf("a=%d b=%d m=%d\n", a,b,m);
    //a,b,m的值为多少？
    return 0;
}

结果为：a=5，b=8，m=7，因为宏是替换的，所以在执行这段语句时会被替换为：

	int m = ((a++) > (b++) ? (a++) : (b++));
	//        a=4  >  b=6用完之后a++，b++，条件为假，a不计算，b需要计算
	//最后m得到7，b的值用完之后进行++，最后b变成8

宏和函数的对比

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

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

那为什么不用函数来完成这个任务？
原因有两点：

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

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

  1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
  2. 宏的代码在预处理阶段就替换成宏的内容对应的代码了所以你调试的时候，执行的代码和你在源代码中看到的代码是不一致的，所以没办法调试
  3. 宏由于类型无关，也就不够严谨。
  4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

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

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

int main()
{
    int* p1 = (int*)malloc(10 * sizeof(int));//是不是有点麻烦
    //那我们可不可以定义一个宏？ 
    int* p2 = MALLOC(10, int);
    //宏替换后：
    int* p2 = (int*)malloc(10 * sizeof(int));

    return 0;
}

函数和宏的对比

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

命名约定

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

把宏名全部大写（容易识别出是宏）
函数名不要全部大写（容易识别出是函数）

#undef

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

#undef NAME
//如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。

在这里插入图片描述

条件编译

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

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

#define PRINT 1//如果屏蔽这条定义则printf不执行
//如果（PRINT）被定义，代码保留
//如果未定义，代码不保留（不参与编译）
int main()
{
#ifdef PRINT
    printf("hahaha");
#endif
    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

以上就是本篇文章的全部内容了，希望大家看完能有所收获

❤️创作不易，点个赞吧❤️
北地小熊丶
关注
  • 29
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C语言学习辅导》预处理1
08-08
理解这些预处理概念对于深入学习C语言至关重要，因为它们直接影响到编译器如何处理源代码，从而影响程序的最终行为。通过实践，我们可以更好地掌握这些概念，并避免由于宏使用不当导致的潜在问题。
预处理（JAVA实现C语言预处理程序）.zip
12-22
总的来说，这个"预处理（JAVA实现C语言预处理程序）"项目为学习编译原理的人员提供了一个实用的工具，帮助他们理解和实现C语言预处理的核心功能。虽然它可能没有涵盖所有预处理的复杂特性，但对于初学者来说，这是一...
C语言程序环境和预处理
十一要变强
04-25 95
主要内容：程序的翻译环境，程序的执行环境，详解：C语言程序的编译+链接，预定义符号介绍，预处理指令 #define，宏和函数的对比，预处理操作符#和##的介绍，命令定义，预处理指令 #include，预处理指令 #undef，条件编译
#define 定义宏 概念和函数的优缺点，使用条件 #undef 宏的副作用 宏使用时的“潜规则“
wo12369874的博客
05-03 275
//#define定义宏---先传参再计算----且不能递归---且字符串里面的宏不能被替换 #define SQUARE(X) X*X//SQUARE(X)必须紧密连接，否则就变为用SQUARE 定义(X) X*X #define SQUARE2(Y) ((Y)*(Y)) #define PRINT(X) printf("the value of "X" is %d",X); int main() { printf("%d\n", SQUARE(3));//9---3*3=9 pri...
C语言程序环境和预处理详解
qq_49613557的博客
03-22 420
C语言程序环境和预处理详解 目录程序的翻译环境程序的执行环境C语言程序编译+链接（详解） 程序的翻译环境 程序的执行环境 C语言程序编译+链接（详解） 正文 程序的翻译环境和执行环境 在ANSI C的任何一种实现中，存在两个不同的环境。 第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。 第2种是执行环境，它用于实际执行代码。 详解编译+链接 翻译环境 组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。 每个目标文件由链接器（linker）捆绑在一起，形成一个
学C/C++想提升功底 可以花点时间看看这篇博客---C语言程序环境和预处理
记录并分享学习编程时的知识点...
11-18 6757
本篇博客介绍了C语言程序环境和预处理.主要包含程序的翻译和运行环境和 各种预处理操作:预定义符号.各种#define 用法 undef的使用条件编译的使用 头文件包含指令
C语言系列(6) --- C语言程序环境和预处理
Fug_Lee的博客
04-20 342
（一）程序的翻译环境和执行环境 翻译环境：在这个环境中源代码被转换为可执行的机器指令。 执行环境：用于实际执行代码。 组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。 链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库， 将其需要的函数也链...
C语言程序环境和预处理Pt.1 - 预处理指令|预处理操作符
BuiderCodes的博客
03-14 960
_FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义。
C语言之程序环境和预处理
Britney_dark的博客
03-26 4043
重点 程序的翻译环境 程序的执行环境 详解：C语言程序的编译+链接 预定义符号介绍 预处理指令 #define 宏和函数的对比 预处理操作符#和##的介绍 命令定义 预处理指令 #include 预处理指令 #undef 条件编译 一. 程序的翻译环境和执行环境 在ANSI C的任何一种实现中，存在两个不同的环境。 第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。 第2种是执行环境，它用于实际执行代码。 二. 详解编译+链接 1.翻译环境 组成..
C语言程序环境和预处理Pt.2 - 宏的命名约定|#undef|命令行定义|条件编译
BuiderCodes的博客
03-20 592
Pt1:C语言程序环境和预处理Pt.1 - 预处理指令|预处理操作符-CSDN博客。
C语言程序环境与预处理命令简介
m0_71526157的博客
10-16 299
大家好，本文篇文章主要是简单讲解一下C语言中的程序环境，以及一些预处理命令语法： #define name stuff举例：#define MAX 1000 //相当于MAX=1000#define reg register //为 register这个关键字，创建一个简短的名字注意：在定义标识符时结尾最好不要加上；可能会出现一些不必要的错误。
[C语言程序设计(第四版)].谭浩强.高清_C语言程序设计第四版_
10-02
总的来说，《C语言程序设计（第四版）》不仅涵盖了C语言的基础知识，还包括了许多实用技巧和编程经验。通过系统学习这本书，初学者可以建立起坚实的C语言基础，为后续的软件开发或系统编程打下坚实的基础。
学习樊媛媛c语言程序设计09-编译预处理.ppt
11-16
第九章 编译预处理是C语言程序设计中的一个重要环节，它涉及到程序在编译前的一些处理步骤，主要包括宏定义、文件包含和条件编译。这些预处理指令以#开头，它们不是C语言的标准语法，而是由编译器在实际编译之前执行...
c语言程序设计教程答案.pdf
06-23
《C语言程序设计教程答案》是一本针对C语言初学者的习题解答指南，由杨路明主编，郭浩志主审。这份资料详细解答了C语言学习过程中的各种问题，帮助学生巩固基础知识，提高编程技能。以下是其中涵盖的一些关键知识点...
c小红的图上划分（牛客127）
最新发布
m0_74310050的博客
07-06 192
用并查集，如果新增边的点没有共同祖先，连通块就减1，只要判断连通块<=r即可满足条件，不用管l的值，因为减少一个连通块，也就是多增一条边，这条边一定会小于原来的值的，答案要的是最大值，所有不用管。有一个无向图，有 n 个点 m 条边，q 个询问，每次给出 L,R，求将图划分为至少 L 个连通块，最多 R个连通块的最大划分价值，若不可划分输出 "NO ANSWER"。图的划分定义为将图划分为一个或多个连通块，对于每个连通块，其点集为其边集中每一条边的两端点的集合，且点集内任意两点均可通过边集里的边互相到达。
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1199
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 488
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
解决分布式环境下session共享问题
shenxiaomo1688的博客
07-06 472
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
在c语言中的用法 预处理
08-31
这些预处理命令能够扩展C语言程序设计的环境，提供了更灵活和高效的代码编写方式。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *2* *3* [C语言中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值