C语言预处理及宏和函数的区别与各自优劣点的详解

已于 2023-08-09 09:45:30 修改
阅读量517 收藏 21
点赞数 24
分类专栏： C语言学习与总结 文章标签： c语言 windows 开发语言
于 2023-07-18 14:03:51 首次发布
wzs@版权
本文链接：https://blog.csdn.net/Wzs040810/article/details/131779267
版权

C语言预处理及宏和函数的区别与各自优劣点的详解

一:#define

1:#define定义标识符

1.1:语法形式

#define name stuff

1.2:实例

#define MAX 1000
#define reg register          //为 register(寄存器)这个关键字，创建一个简短的名字
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
                          date:%s\ttime:%s\n" ,\
                          __FILE__,__LINE__ , \
                          __DATE__,__TIME__ )

在#define定义标识符之后后面不能加;
例如:
#define M 100;
int main()
{
	int a = 0;
	int b = 0;
	if (a < 5)
		b = M;
	else
		b = -1;
	return 0;
}

此时会报错
在这里插入图片描述

在这里插入图片描述

当替换后:
int main()
{
	int a = 0;
	int b = 0;
	if (a < 5)
		b = 100;;
	else
		b = -1;
	return 0;
}
//也就是说else语句前不是if语句,而是空语句即;
所以报错中有:没有匹配if的非法else

那么,怎么书写宏才能够避免这种情况呢?

#define M(x) do{x=100;}while(0)
int main()
{
	int a = 0;
	int b = 0;
	if (a < 5)
		M(b);
	else
		b = -1;
	return 0;
}

此时,代码成功执行

宏替换后:

#define M(x) do{x=100;}while(0)
//这里while(0)后面不要加;
int main()
{
	int a = 0;
	int b = 0;
	if (a < 5)
		do
		{
		   b=100;
		}while(0);
	else
		b = -1;
	return 0;
}

在这里插入图片描述
我们可以再看一个例子

//如果不加换行符会报错
#define INIT_VAL(a,b) do{\
			a = 0;\
			b = 0; \
			}while(0)
//这里while(0)后面不要加;
int main()
{
	int x = 10;
	int y = 20;
	printf("before: x = %d, y = %d\n", x, y);
	if (1)
	{
		INIT_VAL(x, y);
	}
	else
	{
		x = 100;
		y = 100;
	}
	printf("after: x = %d, y = %d\n", x, y);
	return 0;
}

不加换行符会报错
在这里插入图片描述
在这里插入图片描述

宏替换后:

#define INIT_VAL(a,b) do{\
			a = 0;\
			b = 0; \
			}while(0)
//这里while(0)后面不要加;
int main()
{
	int x = 10;
	int y = 20;
	printf("before: x = %d, y = %d\n", x, y);
	if (1)
	{
		do
		{
		   x=0;
		   y=0;
		}while(0);
	}
	else
	{
		x = 100;
		y = 100;
	}
	printf("after: x = %d, y = %d\n", x, y);
	return 0;
}

所以,如果我们想用一个宏向目标代码处插入多条数据时,可以将这多条语句封装到do…while(0)语句中,此时这个语句中可以任意添加语句去成批替换

此处do…while(0)循环的作用:
(1)do…while(0)循环具有花括号语句:可以让宏在替换的时候能够替换多条语句
(2):while(0):让这个循环只执行一次,实现替换

这种结构被称为:do-while-zero结构

2:#define定义宏

2.1:宏定义的介绍

#define机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义
宏（define macro）。
下面是宏的声明方式：
#define name( parament-list ) stuff
其中的 parament - list 是一个由逗号隔开的符号表，它们可能出现在stuff中。
注意：
参数列表的左括号必须与name紧邻。
如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分

2.2:宏定义的替换规则引例

//例如:
#define MAX(x,y) ((x)>(y)?(x):(y))
//反例:
#define SQUARE(x) x*x
int main()
{
	int a = 3;
	int r = SQUARE(a);
	printf("r=%d\n", r);
	r = SQUARE(a+2);
	printf("r=%d\n", r);
	return 0;
}

我们推测答案应该是9跟25,但是:
在这里插入图片描述
这说明宏定义跟函数有所不同,函数是先计算a+2得出5后再传递给函数的形参,但是宏却不一样

那么这么结果到底是怎么得出的呢?

#define SQUARE(x) x*x
int main()
{
	int a = 3;
	int r = 3*3;
	printf("r=%d\n", r);//3*3=9
	r = 3+2*3+2;
	printf("r=%d\n", r);//3+2*3+2=11
	return 0;
}

这样我们就能解释11是怎么得出的了

事实上,宏定义就是这种替换方式,宏定义在编译阶段就已经替换进了代码中

也就是说编译后的代码中是没有类似于这种代码的int r = SQUARE(a);
而是替换成了int r = 3*3;
而:#define SQUARE(x) x*x就直接被删除掉了

那么我们到底应该怎么改呢?

2.3:宏定义的替换规则

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

改为:

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

int main()
{
	int a = 3;
	int r = SQUARE(a);
	printf("r=%d\n", r);
	r = SQUARE(a + 2);
	printf("r=%d\n", r);
	return 0;
}

在这里插入图片描述
可见,此时准确得出了我们想要的结果
那么此时替换为了什么呢?

#define SQUARE(x) ((x)*(x))
int main()
{
	int a = 3;
	int r = ((3)*(3));
	printf("r=%d\n", r);//9
	r = ((3+2)*(3+2));
	printf("r=%d\n", r);//25
	return 0;
}

可见,加括号后的确可以防止操作符优先级的干扰,那么到底要加多少括号才能万无一失呢?
建议是能加的地方都加上括号.

接下来我们再来看一个例子:

#define DOUBLE(x) (x) + (x)
定义中我们使用了括号，想避免之前的问题，但是这个宏可能会出现新的错误。
int a = 5;
printf("%d\n", 10 * DOUBLE(a));

这将打印什么值呢？
看上去，好像打印100，但事实上打印的是55.
我们发现替换之后：
printf("%d\n", 10 * (5) + (5));

由于:乘法运算先于宏定义的加法，所以出现了55
这个问题的解决办法是在宏定义表达式两边加上一对括号就可以了。

即这样

#define DOUBLE(x) ((x) + (x))
我们发现替换之后：
printf("%d\n", 10 * ((5) + (5)));
即50

3:#define替换规则

#define 替换规则
在程序中扩展#define定义符号和宏时，需要涉及几个步骤。
1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先
被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上
述处理过程。
注意：
1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

4:使用#和##

4.1:#

#:作用:把参数插入到字符串中

使用方法:

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

	int b = 15;
	printf("the value of b is %d\n",b);

	float f = 4.5f;
	printf("the value of f is %f\n",f);
	return 0;
}
我们有这么一个需求,可不可以定义一个函数print完成a,b,f三者的打印任务呢?
答案是:不可以,
因为函数的参数必须声明为特定的类型。
所以函数只能在类型合适的表达式上使用。

也就是说:
函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是相同的。

不过宏可以完成这个任务

我们先来介绍关于字符串的一个很容易被忽视的细节

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

在这里插入图片描述
从中我们发现字符串是有自动连接的特点的。
而

	printf("the value of a is %d\n",a);
	printf("the value of b is %d\n",b);
	printf("the value of f is %f\n",f);
	这三个printf函数中这三者的不同点就是
	1:字符串中的a,b,f字符
	2:占位符%d,%d,%f不同

	又因为:字符串是有自动连接的特点的
	所以我们想:
	printf("the value of" "a" "is" "%d" "\n",a);
	printf("the value of" "b" "is" "%d" "\n",b);
	printf("the value of" "f" "is" "%f" "\n",f);
	能不能将这两个不同点当成参数传入呢?

所以我们这样去写
从下面的代码中我们就能够看出#的作用来
也就是:把参数插入到字符串中

#define PRINT(n,format) printf("the value of "#n" is " format "\n",n)
// 当n为a时:  #n:"a"
printf("the value of ""a"" is " "%d" "\n",a);
// 当n为b时:  #n:"b"
printf("the value of ""b"" is " "%d" "\n",b);
// 当n为f时:  #n:"f"
printf("the value of ""f"" is " "%f" "\n",f);
int main()
{
	int a = 20;
	PRINT(a,"%d");

	int b = 15;
	PRINT(b,"%d");

	float f = 4.5f;
	PRINT(f, "%f");
	return 0;
}

在这里插入图片描述
不过,这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中

4.2:##

##可以把位于它两边的符号合成一个符号。
它允许宏定义从分离的文本片段创建标识符。
注：
这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

例子:

#define PT(x,y) x##y
int main()
{
	int Hello0716 = 2024;
	printf("%d\n", PT(Hello,0716));
	return 0;
}

在这里插入图片描述

5.带副作用的宏参数

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

例如:
int a = 10;
int b = ++a;//给b赋值时改变了a,也就是产生了副作用
int b = a + 1;//无副作用
x + 1;//不带副作用
x++;//带有副作用

例子:

#define MAX(a,b) ((a)>(b)?(a):(b))
int c = ((a++) > (b++) ? (a++) : (b++));
问:a,b,c分别等于什么?
int main()
{
	int a = 5;
	int b = 6;
	//int c = MAX(a++,b++);
	int c = ((a++) > (b++) ? (a++) : (b++));
	//         5       6               7
	//这个最后位置的b++这个整体表达式的值是7,这个7赋值给c
	//  7      6                       8
	printf("c=%d\n", c);//7  注意c不是有歧义
	printf("a=%d\n", a);//6
	printf("b=%d\n", b);//8
	return 0;
}

6:宏和函数对比

宏通常被应用于执行简单的运算。
比如在两个数中找出较大的一个。
#define MAX(a,b) ((a)>(b)?(a):(b))
 
那为什么不用函数来完成这个任务？
原因有二：
1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
所以宏比函数在程序的规模和速度方面更胜一筹。
 
2. 更为重要的是函数的参数必须声明为特定的类型。
所以函数只能在类型合适的表达式上使用。反之这个宏却可以适用于整形、长整型、浮点型等可以
用于 > 来比较的类型。
宏是类型无关的。
 
宏的缺点：当然和函数相比宏也有劣势的地方：
1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序
的长度。
2. 宏是没法调试的。
3. 宏由于类型无关，没有类型检查,也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程序容易出现错。

宏有些能力是函数绝对没有的
宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。
#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main094()
{
	//int* p = (int*)malloc(126 * sizeof(int));
	int* p = MALLOC(126, int);//传参方便
	return 0;
}

7:#undef及命名约定

7.1:#undef

#undef
这条指令用于移除一个宏定义
#undef NAME
如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。

7.2:命名约定

一般来讲函数的宏的使用语法很相似。
所以语言本身没法帮我们区分二者。

那我们平时的一个习惯是：

把宏名全部大写
函数名不要全部大写

二:条件编译

在编译一个程序的时候
我们如果要将一条语句（一组语句）编译或者放弃是很方便的。
因为我们有条件编译指令。 比如说：
调试性的代码,删除可惜,保留又碍事,所以我们可以选择性地编译。
条件编译在预编译时执行

1:单分支与多分支的条件编译

1.1 单分支

#define M 1

int main()
{
#if M
	printf("hello");
#endif
	return 0;
}

//等同于注释:
#if 0
int main()
{
	return 0;
}
#endif

1.2 多分支

#define I 2
int main()
{
	#if (I==1)
		printf("(1)执行");
	#elif (I==2)
		printf("(2)执行");
	#else
		printf("(3)执行");
	#endif
	return 0;
}

注意:
1.#if后面必须有#endif
2.#endif前面必须有#if

2:判断是否被定义

判断是否被定义(只关心是否被定义过,而不关心具体的真/假)
 一定不要忘记#endif
 
被定义过则执行
 
#if defined(symbol)   #endif
#ifdef symbol        #endif

 未被定义过才执行
 
#if !defined(symbol)     #endif
#ifndef symbol         #endif

3:嵌套指令

#define FIRST 0
#define SECOND 0
#define OPTION1 1
#define OPTION2 2
#define OPTION3 3
void do_option1()
{
	printf("do_option1\n");
}
void do_option2()
{
	printf("do_option2\n");
}
void do_option3()
{
	printf("do_option3\n");
}
int main()
{
	#if defined(FIRST)
		#ifdef OPTION1
			do_option1();
		#endif
		#ifdef OPTION2
			do_option2();
		#endif
	#elif defined(SECOND)
		#ifdef OPTION3
			do_option3();
		#endif
	#endif
}

在这里插入图片描述

三:文件包含

1:#include<>与""

本地文件包含
#include "filename"
查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。
如果找不到就提示编译错误。

库文件包含
#include <filename>
查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

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

2:嵌套文件包含

在头文件中写入这两种代码中的任意一种都可以防止头文件被重复引用

//防止头文件被重复引用
#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif

//或者
#pragma once

头文件中的 ifndef / define / endif的用处:
防止头文件被重复引用

#include <filename.h> 和 #include "filename.h"的区别:
<>:只在库的标准目录下进行查找
"":先在当前目录下进行查找,如果查找不到,就去库的标准目录下进行查找

四:预定义符号

这些预定义符号都是C语言内置的。

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

int main()
{
	printf("%s\n", __FILE__);
	printf("%d\n", __LINE__);
	printf("%s\n", __DATE__);
	printf("%s\n", __TIME__);
	//printf("%d\n",__STDC__);//当前VS不遵守ANSI_C(标准C)
	//C:\Users\86157\Desktop\gitee总\c - code\C_preprocessing_compilation\C_preprocessing_compilation\test.c
	//90
	//Jul 18 2023
	//13:55 : 48
	return 0;
}

在这里插入图片描述
在这里插入图片描述

以上就是C语言预处理及宏和函数的区别与各自优劣点的详解
的全部内容,希望能对大家有所帮助

program-learner
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
【c语言】宏（#define、#和##和#undef）与函数比较
某薛的黑猫
09-17 2190
#define -定义标识符 ef：#define在预处理阶段替代所有的Max #define Max 100 int main() { printf(&amp;amp;amp;amp;quot;%d\n&amp;amp;amp;amp;quot;, Max); system(&amp;amp;amp;amp;quot;pause&amp;amp;amp;amp;quot;); return 0; } define定义
C语言——预处理，带参宏定义和函数的区别
m0_53415522的博客
10-26 687
本篇主要记录c语言种的预处理命令，主要介绍宏定义和带参宏定义，以及带参宏定义和函数使用的区别，也对一些常见的预处理命令进行了总结！！！
C语言编程宏定义的优缺点,C语言重要知识点总结（二）--内存结构、函数调用过程（栈帧）、宏的优缺点以及##和#的使用...
weixin_42519497的博客
05-18 1398
一、内存结构内存大致可以分为四个部分：代码段，静态存储区，堆，栈。具体划分如下图所示： 栈：在执行函数时，函数内部局部变量的存储单元都可以在栈上创建，函数执行结束后会自动释放内存。栈内存的分配运算内置于处理器的指令中。效率高，但分配的内存容量有限，程序发生错误时，很有可能出现栈溢出。堆：又称为动态内存分配区，程序在执行的时候用malloc或new申请指定大小的内存，程序员自己负责在任何时候用fre...
c语言宏定义函数如何调用
Oliver King 的小窝
09-22 1万+
直接调用即可。如下示例： #include #define sum(b,c){int d=0;d=b+c;printf("两者的和:%d\n",d);} int main() {     int x=0,y=0;     scanf("%d%d",&x,&y);     sum (x,y);     return 0; } 测试通过： #include #include #def
宏定义、define与typedef的区别、预编译、编译、汇编、链接
qq_44778120的博客
12-27 1662
二、宏定义、define与typedef的区别、预编译、编译、汇编、链接 1、typedef与#define 1、define：宏定义，c语言中预处理命令一种。 宏：宏（Macro）是一种批量处理的称谓。计算机科学里的宏是一种抽象（Abstraction）它根据一系列预定义的规则替换一定的文本模式。解释器或编译器在遇到宏时会自动进行这一模式替换。对于编译语言，宏展开在编译时发生，进行宏展开的工具常被称为宏展开器。 计算机语言如C或汇编语言有简单的宏系统，由编译器或汇编器的预处理器实现。C的宏预处理器的工作只
宏定义与预处理、函数和函数库-C语言专题第6部分
06-08
本课程综合讲解了C语言的预处理和宏定义，详细讲述了宏定义的细节规则和头文件包含等常用预处理；然后讲述了函数的使用、函数库的使用，静态链接库和动态链接库等的制作和使用。本章的目标是提升大家对函数及函数库...
浅谈内联函数与宏定义的区别详解
12-31
文章（一）内联函数与宏定义　在C中，常用预处理语句#define来代替一个函数定义。例如：　#define MAX(a，b) ((a)>(b)?(a):(b))　该语句使得程序中每个出现MAX(a,b)函数调用的地方都被宏定义中后面的表达式((a)>(b)?...
C语言预处理详解
01-05
文字版！清晰度一定让你满意！关于C语言预处理不可多得的宝贝！
c语言预处理和条件编译
11-09
学习c语言一些基本知识。
第八讲C语言函数与预处理力天手把手教你学单片机之优秀文档.ppt
最新发布
11-30
【C语言函数与预处理】是C编程中的核心概念，对于理解和编写单片机程序至关重要。函数是将一组相关操作封装在一起的代码块，可以被多次调用，减少了代码重复，提高了程序的可读性和可维护性。预处理则是C语言编译...
C语言高级-预处理、函数、函数库
钟浩森的博客
03-23 956
第一点 关于预处理 程序执行的过程 (1)源码.c->(编译)->elf可执行程序 (2)源码.c->(编译)->目标文件.o->(链接)->elf可执行程序 (3)源码.c->(编译)->汇编文件.S->(汇编)->目标文件.o->(链接)->elf可执行程序 (4)源码.c->(预处理)->预处理过的.i源文件->(编译)->汇编文件.S->(汇编)->目标文件.o->(链接)-&gt
C语言预处理和函数
哎呦哥哥的博客
05-28 2190
预处理 预处理是C语言中的一个重要特性，值得我们深入讨论， 源代码到可执行程序 源代码经过编译。生成.o文件，再经过链接，成为elf可执行程序，但是实际上，源码经过编译之后，不是直接的.o文件，而是汇编文件.S，汇编文件经过汇编，才得到目标文件.o，所以说，C语言程序需要先被编译成汇编文件，再把汇编文件编译为目标文件，但是更进一步，在源码被编译成汇编文件之前，需要先进行预处理，也就是我们这个
面经-C语言基础(二)
AlanfengLiu的博客
09-28 897
目录 C 语言中全局变量、局部变量、函数参数个是在什么时候分配内存空间 const符号表机制 const的作用 大小端模式 关键字volatile有什么含意? 并给出三个不同的例子。 #include 和#include “filename.h” 有什么区别？ const 有什么用途？（请至少说明两种） 如何引用一个已经定义过的全局变量？ 带参宏与带参函数的区别(至少说出5点)？ 数组名和指针的区别： 关键字inline必须与函数定义放在一起才能使函数成为内联 #if...
C语言之预处理
Limit_Fly的博客
06-21 2207
文章目录预处理定义 预处理定义 程序设计领域中，预处理一般是指在程序源代码被翻译为目标代码的过程中，生成二进制代码之前的过程。典型地，由预处理器(preprocessor) 对程序源代码文本进行处理，得到的结果再由编译器核心进一步编译。这个过程并不对程序的源代码进行解析，但它把源代码分割或处理成为特定的单位——（用C/C++的术语来说是）预处理记号(preprocessing token)用来支持...
c语言编译过程详解，预处理，编译，汇编，链接(干货满满）
热门推荐
编程爱好者的博客
07-27 11万+
锲子 我们在各自的电脑上写下代码，得明白我们代码究竟是如何产生的，不想了解1，0什么的，但这几个环节必须掌握吧。 我们的代码会经过这4个环节，从而形成最终文件，c语言作为编译语言，用来向计算机发出指令。让程序员能够准确地定义计算机所需要使用的数据，并精确地定义在不同情况下所应当采取的行动。 预处理， 展开头文件/宏替换/去掉注释/条件编译 （t...
c语言预处理及宏函数知识点总结
寄蜉蝣于天地，渺沧海之一粟
08-15 195
c语言预处理及宏函数知识点总结
C语言的预处理
weixin_44614083的博客
12-28 1594
预处理 预处理预处理前言一、预定义符号二、#define1.宏2.宏与函数3.带副作用的宏参数4. 宏和函数的不同5.#undef三、条件编译四、文件包含1.函数库文件包含2.本地文件包含总结 前言 编译一个C语言程序涉及很多步骤。其中第一个步骤被称为预处理。C语言的预处理器在源代码编译之前对其进行一些文本性质的操作。它的主要任务包括删除注释、插入被#include指令包含的文件内容、定义和替换由#define指令定义的符号，同时确定代码的部分内容是否应该根据一些条件编译指令进行编译。 一、预定义符
【C语言】之预处理命令
王廷云的博客
03-12 2601
定义： 预处理器在源代码进行编译之前对其进行一些文本性质的操作； 提供以下三种预处理功能： 1. 宏定义 (#define) 2. 文件包含 (#include &lt;stdio.h&gt;) 3. 条件编译 (#if #else #endif #ifndef #ifdef) 注：这些预处理命令是由ANSI C统一规定的，它不是C语言本身的组成部分，不能对其直接进行编译。...
c语言中预处理函数有哪些,C语言中的函数与预处理
weixin_39965673的博客
05-20 441
前言C语言中的函数和预处理相关知识，你真的了解吗？你知道C中函数中的调用顺序是由什么判断的吗？对于预处理的#include应该如何看待呢？接下来，本文讲述关于C语言中的函数与预处理的相关知识。函数Python并不像C语言那样是一种全能语言，它是一种中级语言。标准库函数通常看上去很简单，并且有缺陷。函数调用顺序int a=f()+g()*h();这三个函数的执行顺序是不确定的，而C标准将选择顺序的权...
C语言（函数与预处理、指针）
qq_44578883的博客
01-29 1032
#一、函数与预处理 （一）一维数组 1.一维数组的定义格式为： 类型说明符 数组名［常量表达式］； 例如： int a[10]; 它表示定义了一个整形数组，数组名为a，有10个元素。 2.在定义数组时，需要指定数组中元素的个数，方括弧中的常量表达式用来表示元素的个数，即数组长度。 3.常量表达式中可以包括常量和符号常量，但不能包含变量。 注意： C语言不允许对数组的大小作动态定义，即数组的大...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

program-learner

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值