C语言进阶--程序环境和预处理

已于 2023-07-07 11:25:42 修改
阅读量214 收藏 1
点赞数 1
分类专栏： c语言 文章标签： c语言
于 2023-07-07 11:23:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36194037/article/details/131563877
版权

目录

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

1.1.翻译环境

​编辑    ​编辑

预编译(预处理)：

编译：

汇编：

链接：

1.2.运行环境

二.预处理详解

2.1.预定义符号

2.2.#define

#define定义标识符

#define定义宏

#define替换

#和##

带副作用的宏参数

宏和函数的对比

命名约定

#undef

命令行定义

三.条件编译

四.文件包含

4.1.本地文件包含

4.2.函数库文件包含

4.3.嵌套文件包含

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

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

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

1.1.翻译环境

翻译阶段由几个步骤组成，组成一个程序的每个(有可能有多个)源文件通过编译过程分别转换为目标代码(object code)。然后，各个目标文件由链接器(linker)捆绑在一起，形成一个单一而完整的可执行程序。链接器同时也会引入标准C函数库的任何被该程序所用到的函数，而且它也可以搜索程序员个人的程序库，将其中需要使用的函数也链接到程序中。

编译过程本身也由几个阶段组成，首先是预处理器(preprocessor)处理。在这个阶段，预处理器在源代码上执行一些文本操作。例如，用实际值代替由#define指令定义的符号以及读入由#define指令包含的文件的内容。然后，源代码经过解析(parse)，判断它的语句的意思。第2个阶段是产生绝大多数错误和警告信息的地址。随后，便产生目标代码。目标代码是机器指令的初步形式，用于实现程序的语句。如果我们在编译程序的命令中加入了要求进行优化的选项，优化器(optimizer)就会对目标代码进一步进行处理，使它效率更高。优化过程需要额外的时间，所以在程序调试完毕并准备生成正式产品之前一般不进行这个过程。至于目标代码是直接产生的，还是先以汇编语句的形式存在，然后再经过一个独立的阶段编译成目标文件，对我们来说并不重要。

接下来，我们将在Linux环境下的gcc编译器进行翻译环境的讲解：

       

预编译(预处理)：

gcc -E test.c -o test.i  
gcc -E add.c -o add.i

预处理完成之后就停下，预处理产生的结果都放在test.i和add.i中。

  1. 完成头文件的包含；
  2. 完成#define定义的符号和宏的替换；
  3. 删除注释；
  4. 文件操作

编译：

gcc test.i -S 
gcc add.i -S

把C语言代码转换为汇编代码，编译完成之后就停下，编译产生的结果都放在test.s和add.s中。

  1. 语法分析；
  2. 词法分析；
  3. 语义分析；
  4. 符号汇总(只会汇总一些全局的符号)。

汇编：

gcc test.s -c
gcc add.s -c

把汇编指令翻译成二进制指令，形成符号表。汇编完成之后就停下，汇编产生的结果保存在test.o和add.o中。在Windows环境下，目标文件后缀名为.obj，在Linux gcc编译环境下后缀名为.o。其中Windows环境下文件是elf格式文件，elf格式文件是以段表的形式组织的，应使用工具readelf阅读elf格式的文件。

  1. 将汇编指令转换为二进制指令；
  2. 产生符号表 。 

符号表：

将编译阶段汇总的符号以及符号所对应的地址进行汇总，一张符号表包含符号名和符号所对应的存储地址。

源文件中可能存在无法通过当前符号所在的文件找到其对应的存储地址，如源文件test.c中的符号add，由于是外部符号，add函数并没有在源文件test.c中定义，因此在编译阶段无法获取符号Add的地址。对于此类符号，符号表中会暂时存储一个虚拟地址，等待链接阶段进行符号表合并及重定位时进行统一处理。

链接：

在链接阶段主要完成如下俩个任务：

  1. 合并段表
  2. 符号表的合并和重定位

合并段表：

生成的.o文件是elf格式的，这种elf格式的文件是由一些段表组成，在链接阶段要把这些目标文件中的段表合并成一个段表。

符号表的合并和重定位：

在汇编阶段会生成多张符号表，在链接阶段会多张符号表会被合并为一张。同时，同时会将对应符号的虚拟地址通过重定位转换成对应的实际地址。

1.2.运行环境

程序执行的过程：

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

二.预处理详解

编译一个C程序涉及很多步骤。其中第一个步骤被称为预处理阶段。C预处理器在源代码编译之前对其进行一些文本性质的操作。它的主要任务包括删除注释，插入被#include指令包含的文件的内容，定义和替换由#define指令定义的符号以及确定代码的部分内容是否应该根据一些条件编译指令进行编译。

2.1.预定义符号

下表总结了由预处理器定义的符号。它们的值或者是字符串常量，或者是十进制数字常量。

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

案例： 

int main()
{
	FILE* pf = fopen("log.txt", "a");
	if (pf == NULL)
	{
		perror("fopen");
		return 1;
	}

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		//printf("file:%s line:%d date:%s time:%s i=%d\n", __FILE__, __LINE__, __DATE__, __TIME__, i);
		//printf("name:%s file:%s line:%d date:%s time:%s i=%d\n",__func__, __FILE__, __LINE__, __DATE__, __TIME__, i);
		fprintf(pf,"name:%s file:%s line:%d date:%s time:%s i=%d\n", __func__, __FILE__, __LINE__, __DATE__, __TIME__, i);
	}

	fclose(pf);
	pf = NULL;

	return 0;
}

2.2.#define

#define定义标识符

语法：

#define name stuff

有了这条指令以后，每当有符号name出现在这条指令后面时，预处理器就会把它替换成stuff。

替换文本并不仅限于数值字面值常量。使用#define指令，可以把任何文本替换到程序中。比如：

#define reg register  //为关键字register创建一个简短的名字reg
#define do_forever for(;;)  //用一个更具描述性的符号来代替一种用于实现无限循环的for语句类型
#define CASE break;case  //自动地把一个break放在每个case之前

int main()
{
	reg int num = 0;//寄存器变量

	do_forever;

	int n = 0;
	switch (n)
	{
	case 1:
		CASE 2 ://同break;case 2
			CASE 3 :
	}

	return 0;
}

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

#define NUM 100;

int main()
{
	int num = 0;

	if (1)
		num = NUM;//num=100;;
	else
		num = -1;

	return 0;
}

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

#define定义宏

#define机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏或定义宏。下面是宏的声明方式：

#define name(parameter-list) stuff

其中，parameter-list(参数列表)是一个由逗号分隔的符号列表，它们可能出现在stuff中。参数列表的左括号必须与name紧邻。如果两者之间由任何空白存在，参数列表就会被解释为stuff的一部分。

案例一：

#define SQUARE(x) x*x

int main()
{
	int a = 10;

	int r = SQUARE(a);

	printf("%d\n", r);

	return 0;
}

当a=10时，此时的ret=10*10=100；

但是这个宏存在一个问题，当x取a+1时，也就是SQUARE(a+1)。乍一看，你可能觉得这段代码将打印121。事实上，它将打印21。参数x被文本a+1替换，所以这条语句实际上变成了：a+1*a+1。现在问题清楚了：由替换产生的表达式并没有按照预想的次序进行求值。在宏定义中加上两个括号，这个问题便很轻松地解决了：

#define SQUARE(x) (x)*(x)

案例二：

#define DOUBLE(x) (x)+(x)

int main()
{
	int b = 20;

	int ret = 3 * DOUBLE(b);

	printf("%d\n",ret);

	return 0;
}

定义中使用了括号，用户避免前面出现的问题。但是，使用这个宏，可能会出现另外一个不同的错误。当b=5时，看上去，它好像将打印30，但事实上它打印的是20.再一次，通过观察宏替换产生的文本，我们能够发现问题所在：3*(b)+(b)。乘法运算在宏所定义的加法运算之前执行。这个错误很容易修正：在定义宏时，你只要在整个表达式两边加上一对括号就可以了。

提示：

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

#define替换

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

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

注意：

  1. 宏参数和#define定义可以包含其它#define定义的符号。但是，宏不可以出现递归，因为宏只做简单的文本替换，且只替换一次；
  2. 当预处理器搜索#define定义的符号时，字符串常量的内容并不进行检查。

#和##

如果想把宏参数插入到字符串常量中，可以使用两种技巧。

首先，邻近字符串自动链接的特性使我们很容易把一个字符串分成几段，每段实际上都是一个宏参数。比如：

int main()
{
	char* s = "hello ""bit\n";
	printf("%s", s);

	printf("hello bit\n");

	printf("hello ""bit\n");

	return 0;
}

运行结果：

这里有一个这种技巧的例子：

 
#define PRINT(FORMAT,VALUE) printf("the value is " FORMAT "\n", VALUE)

int main()
{
	int i = 2;

	PRINT("%d", i + 3);

	return 0;
}

运行结果：

这种技巧只有当字符串常量作为宏参数给出时才能使用。

第2个技巧使用预处理器把一个宏参数转换为一个字符串。#argument这种结构被预处理器翻译为“argument”。这种翻译可以让你像下面这样编写代码：

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

int main()
{
	int a = 20;
	double pai = 3.14;

	PRINT(a, "%d");

	PRINT(pai, "%lf");

	return 0;
}

运行结果：

##结构则执行一种不同的任务。它把位于它两边的符号链接成一个符号。作为用途之一，它允许宏定义从分离的文本片段创建标识符。比如：

#define CAT(name,num) name##num

int main()
{
	int class105 = 105;
	printf("%d\n", CAT(class, 105));//CAT(class, 105)转换为class105，而class105的值为105，所以打印输出105

	return 0;
}

运行结果：

带副作用的宏参数

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

x+1;//不带副作用
x++;//带副作用

MAX宏可以证明具有具有副作用的参数所引起的问题，如下所示：

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

int main()
{
	int a = 5;
	int b = 8;
	int c = MAX(a++, b++);
	//int c = ((a++) > (b++) ? (a++) : (b++));

	printf("%d\n", c);//9
	printf("%d\n", a);//6
	printf("%d\n", b);//10

	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));

	MALLOC(10, int);

	return 0;
}
        属性                    #define 宏                           函数
     代码长度每次使用时，宏代码都被插入到程序中。除了非常小的宏之外，程序的长度将大幅度增长函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码
     执行速度更快存在函数调用/返回的额外开销
  操作符优先级宏参数的求值是在所有周围表达式的上下文环境里，除非它们加上括号，否则邻近操作符的优先级可能会产生不可预料的结果函数参数只在函数调用时求值一次，它的结果值传递给函数。表达式的求值结果更容易预测。
     参数求值参数每次用于宏定义时，它们都将重新求值。由于多次求值，具有副作用的参数可能会产生不可预估的结果参数在函数被调用前只求值一次。在函数中多次使用参数并不会导致多种求值过程。参数的副作用并不会造成任何特殊的问题
     参数类型宏与类型无关。只要对参数的操作是合法的，它可以使用任何参数类型函数的参数是与类型有关的。如果参数的类型不同，就需要使用不同的函数，即使它们执行的任务是相同的

命名约定

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

#undef

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

#define M 100
int main()
{
	int a = M;

#undef M

	printf("%d\n", M);//err：未声明的标识符

	return 0;
}

如果一个现存的名字需要被重新定义，那么它的就定义首先必须用#undef移除。

命令行定义

许多C编译器提供了一种能力，允许你在命令行中定义符号。用于启动编译过程。当我们根据同一个源文件编译一个程序的不同版本时，这个特性是很有用的。例如，假定某个程序声明了一个某种长度的数组。如果某个机器的内存很有限，这个数组必须很小，但在另一个内存充裕的机器上，你可能希望数组能够大一些。如果数组是用类似于下面的形式进行声明的，

int main()
{
	int arr[ARRAY_SIZE];

	int i = 0;
	for (i = 0; i < ARRAY_SIZE; i++)
	{
		arr[i] = i;
	}

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

	printf("\n");

	return 0;
}

那么，在编译程序时，ARRAY_SIZE的值可以在命令行中指定。在Linux编译器中，-D选项可以完成这项任务。如下面这条指令：

gcc test.c -D ARRAY_SIZE=10

三.条件编译

在编译一个程序时，如果我们可以选择某条语句或某组语句进行翻译或者被忽略。常常会显得很方便。条件编译就是用于实现这个目的。使用条件编译，你可以选择代码的一部分是被正常编译还是完全忽略。

案例一：

/*
#if 常量表达式

#endif
*/
//常量表达式由预处理器求值

int main()
{
	int arr[10] = { 0 };
	int i = 0;

	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
#if 1
		printf("%d ",arr[i]);
#endif
	}

	return 0;
}

案例二：

//多个分支的条件编译
/*
#if 常量表达式

#elif 常量表达式

#else

#endif
*/

#define NUM 1

int main()
{
#if NUM==1
	printf("hehe\n");
	return 0;
#elif NUM==2
	printf("haha\n");
#else
	printf("heihei\n");
#endif

	return 0;
}

案例三：

//判断是否被定义
/*
#if defined(symbol)
#ifdef symbol

#if !defined(symbol)
#ifndef symnol
*/

#define MAX 0

int main()
{

//#if defined(MAX)
//	printf("hehe\n");
//#endif

//#if !defined(MAX)
//	printf("hehe\n");
//#endif

//#ifdef MAX
//	printf("hehe\n");
//#endif

#ifndef MAX
	printf("hehe\n");
#endif

	return 0;
}

案例四：

//嵌套指令
/*
#if defined(OS_UNIX)
    #ifdef OPTION1
	
	#endif
	#ifdef OPTION2

	#endif
#elif defined(OS_MSDOS)
    #ifdef OPTION2

	#endif  
*/

四.文件包含

我们知道，#include指令可以使另一个文件的内容被编译。就像它实际出现于#include指令出现的位置一样。这种替换执行的方式很简单︰预处理器删除这条指令，并用包含文件的内容取而代之。这样，一个头文件如果被包含到10个源文件中，它实际上被编译了10次。

4.1.本地文件包含

#include"filename"

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

/usr/include

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

C:\Program File (x86)\Microsoft Visual Studio 9.0\VC\include

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

4.2.函数库文件包含

#include<filename.h>

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

这样是不是可以说，对于库文件也可以使用" "的形式包含？答案是肯定的。但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地问价了。

4.3.嵌套文件包含

标准要求编译器必须支持至少8层的头文件嵌套，但它并没有限定嵌套深度的最大值。事实上，我们并没有很好的理由让#include指令的嵌套深度超过一层或两层。

嵌套文件包含的不利之处：

  1. 它使得我们很难判断源文件之间的真正依赖关系；
  2. 一个头文件可能会被多次包含。

多重包含在绝大多数情况下出现于大型程序中，它往往需要使用很多头文件，因此要发现这种情况并不容易。要解决这个问题，我们可以使用条件编译。

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
//endif

或者使用：

#pragma once

这样就可以避免头文件的重复引入。

别是清欢
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言进阶-牟海军.pdf
07-25
本书是一本修炼C程序设计能力的进阶之作，它没有系统地去讲解C语言的语法和编程方法，而是只对C语言中不容易被初学者理解的重点、难点和疑点进行了细致而深入的解读，揭露了C语言中那些鲜为普通开发者所知的秘密，...
C语言进阶 作者 Wrestle.Wu
06-20
本书是一本修炼C程序设计能力的进阶之作，它没有系统地去讲解C语言的语法和编程方法，而是只对C语言中不容易被初学者理解的重点、难点和疑点进行了细致而深入的解读，揭露了C语言中那些鲜为普通开发者所知的秘密，...
C语言进阶-程序环境和预处理
~
10-09 1568
前言 本章主要讲解点： 代码编译链接变成可执行程序程序的过程 程序的翻译环境和执行环境 任何一个代码从源文件（.c文件）到可执行文件（.exe文件）都经历了两个环境： 翻译环境： 在这个环境中源代码被转换为可执行的机器指令 执行环境： 用于实际执行代码 图示： 编译+链接 编译： 组成一个程序的每个源文件（.c文件）通过编译过程分别转换成目标代码（.obj文件） 链接： 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序（.exe文件） 链接
C语言进阶 -- 程序环境和预处理
weixin_72481085的博客
07-19 137
C语言进阶 -- 程序环境和预处理
C语言进阶---程序环境和预处理
weixin_75128035的博客
10-08 1002
每有欣喜，必有遗憾，不能与你分享，许多事不再那么有意义。
c语言进阶-第7节-程序环境和预处理
qq_45113223的博客
02-25 928
1. 程序的翻译环境和执行环境 在ANSI C（遵循美国国家标准总局定义的c语言标准的c语言）的任何一种实现中，存在两个不同的环境。 第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令 第2种是执行环境，它用于实际执行代码 test.c里面存的是c语言的源代码 test.exe是二进制文件，里面存的是二进制指令/机器指令（机器能够读懂的是二进制，二进制指令是机器能够读懂的，因此也叫机器指令） 翻译环境就是将test.c中的c语言的源代码翻译成test.exe中机器能够读懂的二进
C语言进阶-程序环境与预处理
m0_73224619的博客
04-05 288
这里我们画个图单独聊聊符号汇总局部变量只有在函数运行起来才会创建，所以在编译阶段是看不到他们的，全局变量是可以看到的。
手撕C语言进阶---程序编译
Edward_Asia的博客
10-14 379
程序的翻译环境和执行环境 在ANSI C的任何一种实现中，存在两个不同的环境。 第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。 第2种是执行环境，它用于实际执行代码。 详解编译+链接 翻译环境 组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。 链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程序员个人的程序库，将其需要的函数也链接
程序环境和预处理-C语言进阶
ma123456542的博客
10-26 63
_FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器（gcc）遵循 ANSI C，其值为 1，否则未定义（VS编译器不遵循）这些与定义符号都是语言内置的。gcc编译器是严格遵循 ANSI C。int i = 0;i < 10;pf = NULL;return 0;
【7】C语言进阶--程序的编译（预处理操作）+链接
保持热爱，奔赴山海。
08-06 222
/ 预定义符号__FILE__ //进行编译的源文件__LINE__ // 文件当前的行号__DATE__ // 文件被编译的日期__TIME__ // 文件被编译的时间__STDC__ // 如果编译器遵循ANSIC，其值为1，否则未定义// 预定义符号/* __FILE__ //进行编译的源文件__LINE__ // 文件当前的行号__DATE__ // 文件被编译的日期__TIME__ // 文件被编译的时间。.........
Java最新C语言进阶-程序环境和预处理_c语言为定义的标识符，美团Java面试
最新发布
2401_84584375的博客
05-11 864
内置预定义符号：__FILE__ //进行编译的源文件（文件绝对路径）__LINE__ //当前代码的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义（gcc有定义，vs没有）//注意是两个下划线示例：语法：示例：#define reg register //为 register这个关键字，创建一个简短的名字;) //用更形象的符号来替换一种实现//注：用于执行死循环。
C语言进阶学习资料，关于预处理，文件处理，结构体，位移运算的学习 大学生期末复习资料，程序设计课程复习资料
04-19
本资料集为C语言进阶学习者提供了全面的预处理、文件处理、结构体和位移运算的知识。内容涵盖了从基础语法到高级应用的各个方面，旨在帮助学习者深入理解C语言的核心概念和技术细节。 适用人群 本资料适合具有C语言...
C语言进阶语法与编程技巧.md
08-12
目录： 结构体与联合体 1.1 定义与声明 1.2 访问结构体成员 内存管理 2.1 动态内存分配 ...预处理指令与宏 5.1 #include与#include_once 5.2 宏的定义与使用 多文件程序 6.1 头文件与源文件 6.2 链接多个源文件
c语言中，求1到n的阶乘之和
热门推荐
weixin_36194037的博客
10-20 4万+
#define _CRT_SECURE_NO_WARNINGS 1 #include"stdio.h" #include"stdlib.h" int main() { int n = 0; printf("请输入一个数字: "); scanf("%d",&n); int i = 0; int ret = 1; int sum = 0; for (i = 1; i <= n; i++)
堆栈溢出一般是由什么原因导致的？
weixin_36194037的博客
12-22 3万+
题目：堆栈溢出一般是由什么原因导致的？ 答：1.函数调用层次太深。函数递归调用时，系统要在栈中不断保存函数调用时的现场和产生的变量，如果递归调用太深，就会造成栈溢出，这时递归无法返回。再有，当函数调用层次过深时也可能导致栈无法容纳这些调用的返回地址而造成栈溢出。 2.动态申请空间使用之后没有释放。由于C语言中没有垃圾资源自动回收机制，因此，需要程序主动释放已经不再使用的动态地址空间。申请的动态空
关于vs2013版试用期结束后如何激活的一些经验总结
weixin_36194037的博客
10-20 1万+
最近忙着进行编程，中午打开vs2013界面，突然显示结果告诉我，我的试用期已结束，当时脑子里一片茫然，怎么会出现这个问题，思索片刻，然后就去百度搜索了下，现在把方法汇总如下，以供大家参考： 1.Visual Studio 2013旗舰版试用期结束后便不能正常使用，但是可以通过输入密钥的方式进行激活，经过尝试发现可以通过下面的方式进行激活并正常使用。 (1)首先，打开VS2013,找到注册产品；
写一个函数找出一个整数数组中，第二大的数
weixin_36194037的博客
03-02 1万+
题目：写一个函数找出一个整数数组中，第二大的数。 算法分析： 1）假设数组中的前两个元素就是最大和第二大，即max和smax； 2）从数组的第二个元素开始遍历数组，当有元素大于max的时候，将max赋值给smax，再将最大的那个元素赋值给max； 3）如果当前元素小于max，并且大于smax，那么就让smax当前元素。 算法实现： 方法一： #include&lt;stdio.h&g...
全局变量和局部变量在内存中是否有区别？如果有，是什么区别？
weixin_36194037的博客
12-22 5460
答：有区别。 全局变量保存在内存的全局存储区，占用静态的存储单元；局部变量保存在栈中，只有在所在函数被调用时才动态地为变量分配存储单元。引申： C语言经过编译之后将内存分为以下五个区域 1.栈：由编译器进行管理，自动分配和释放，存放函数调用过程中的各种参数，局部变量，返回值及函数返回地址。操作方式类似数据结构中的栈。 2.堆：用于程序动态申请分配和释放空间。C语言中的malloc和free,
A - 小C语言--词法分析程序
09-05
- *1* [小C语言--词法分析程序](https://blog.csdn.net/wq3699823668/article/details/100599572)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值