C语言细节 预处理器

最新推荐文章于 2023-03-24 10:15:00 发布
最新推荐文章于 2023-03-24 10:15:00 发布
阅读量256 收藏 1
点赞数
文章标签： c语言 预处理器 文件包含 宏 泛型选择表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46131409/article/details/109756572
版权 
"C预处理器"在程序执行前查看程序(故有此名).根据程序中的预处理器指令,预处理器把符号缩写替换为其表示的内容(如包含程序所需的其
他文件,或选择让编译器查看哪些代码).预处理器并不知道C,而基本上只是把一些文本替换为另一些文本.预处理器对标识符的要求和C编译
器相同:①由字母/数字/下划线组成 ②只能以字母开头

一.翻译处理

在预处理之前,编译器需要对程序进行一些翻译处理:
①编译器把源码中出现的字符映射到源字符集.该过程处理多字节字符和三字符序列
②编译器定位每个反斜杠(\)后面跟着换行符的实例,并删除它们,也就是说把多个"物理行"(Physical Line)转换成1个"逻辑行"(Logical Line):
printf("That's wond\
       erful\n");     →     printf("That's wonderful\n")
由于预处理表达式的长度必须是1个逻辑行,所以这1步为预处理器做好了准备工作
③编译器会将文本划分成"预处理记号序列"(记号的概念参见 二.5 部分),"空白序列"和"注释序列".编译器用1个空格字符替换1条注释,故有:
int/*这相当于空格*/fox;     →     int fox;
而且,实现可以用1个空格替换所有空白字符序列(不包括换行符)

经过翻译处理后,程序已经准备好进入预处理阶段,预处理器会查找1行中以#为起始的预处理指令

二.宏

宏通过#define指令定义.每个#define指令由3个部分组成(见下图):
①#define本身
②选定的缩写,称为"宏"(Macro),其中不允许有空格,且必须遵循C变量的命名规则
  有些宏代表值,称为"类对象宏"(Object-Like Macro)
  还有些宏代表,称为"类函数宏"(Function-Like Macro)
③指令的其余部分称为"替换列表"或"替换体",是预处理器用于替换宏的文本
  这个替换的过程称为"宏展开"(Macro Expansion)

在这里插入图片描述
1.类对象宏
(1)语法:

//宏定义:
#define <Macro> <sub>
  //文件中的<Macro>会被直接替换为<sub>
  //参数说明:
    Macro:指定宏名
      //其中不能有空格;通常由大写字母构成,尤其是对类对象宏来说
    sub:指定替换体
      //其中可以有空格

//宏调用:
<Macro>

和其他预处理器指令一样,#define以#作为1行的开始.ANSI C和之后的标准都允许#前有空格/制表符,但#和define之间不能有空格;而旧版本的C要求
该指令从1行的最左侧开始.该指令从#开始,到后面的第1个换行符结束,也就是说,指令的长度仅限于1个逻辑行.在#define指令所在的逻辑行中可以插
入注释,并且每条注释都会被1个空格代替.指令可以出现在源文件中的任何位置,从出现的位置到文件结尾有效

(2)定义明示常量:

"明示常量"(Manifest Constant)又称"符号常量"或"宏常量",通过预处理器指令#define来定义得到:
#include <stdio.h>
#define TWO 2
#define OW "Consistency is the last refuge of the unimagina\
tive. - Oscar Wilde"

int main(void) {
	printf("%d\n",TWO);//结果:2
	printf("%s\n",OW);//结果:Consistency is the last refuge of the unimaginative. - Oscar Wilde
	return 0;
}

(3)其他用法:

#include <stdio.h>
#define TWO 2
#define PX printf("x is %d\n",x);
#define FOUR TWO*TWO
#define FMT "x is %d\n"
#define OW "Consistency is the last refuge of the unimagina\
tive. - Oscar Wilde"//注意:第2个物理行开始处不能有空格,否则替换后也会有空格
#define OW2 "Consistency is the last refuge of the unimagina\
     tive. - Oscar Wilde"

int main(void) {
	int x=TWO;
	PX;//结果:x is 2
	x=FOUR;//FOUR→TWO*TWO→2*2
	printf(FMT,x);//结果:x is 4//注意:一些编译器不支持
	printf("%s\n",OW2);//结果:Consistency is the last refuge of the unimagina     tive. - Oscar Wilde
	return 0;
}

(4)例外:

通常来说,预处理器会用和宏等价的替换体替换程序中的宏.如果替换后还有宏,则继续替换,直到所有宏都被替换掉.但双引号中的宏是例外:
#define OW "ooooo"
int main(void) {
    printf("OW\n");//结果:OW
    return 0;
}
也就是说,双引号中的宏不会被替换.对类对象宏和类函数宏来说都是如此

(5)对替换体的解释:

C预处理器"记号"(Token)是宏定义的替换体中由空格/制表符/换行符分隔的项,如:
#define FOUR 2*2
该宏定义有1个记号:2*2.而:
#define FOUR 2 * 2
该宏定义有3个记号:2,*,2
宏定义中的替换体可能被预处理器解释为"记号型字符串"或"字符型字符串".在替换体中有空格时,对记号型字符串和字符型字符串的处理方式不同:对字
符型字符串,包括空格在内的整个替换体会被视为1个记号;而对记号型字符串,空格会被视为替换体中各记号的分隔符,如:
#define FOUR 2 * 2
如果预处理器把该替换体解释为记号型字符串,则用3个记号(2,*,2,分别用空格分隔)来替换FOUR;如果解释为字符型字符串,则用2 * 2替换FOUR.不同
的预处理器会进行不同的解释,但这种区别只在个别复杂的情况下才有实际意义

另外,C编译器处理记号的方式比预处理器复杂.比如说,由于编译器理解C语言的规则,所以不要求代码中用空格来分隔记号.如编译器可以把2*2直接视为3
个记号,引物它可以识别出2是常量而*是运算符

(6)重定义常量:
在这里插入图片描述
在这里插入图片描述
2.类函数宏
(1)语法:

//宏定义:
#define <Macro>(<param1>,<param2>...) <sub>
  //尽管形式上相似,但类函数宏的行为和函数调用完全不同:程序中的宏先被替换体替换,替换体中的形参再被宏调用时传入的实参替换(见 (2) 部分)
  //参数说明:其他参数同上
    param:指定宏的参数(形参)
      //这些参数将出现在<sub>中

//宏调用:
<Macro>(<val1>,<val2>...)
  //参数说明:
    val:指定传入的参数(实参)

//实例:
#include <stdio.h>
#define SQUARE(X) X*X
#define PR(X) printf("The result is %d\n",X); 

int main(void) {
	int x=2;
	int z=SQUARE(x);
	PR(z);//结果:The result is 4//由于替换体结尾已经有引号了,这里结尾没有引号也可以
	z=SQUARE(2);
	PR(z);//结果:The result is 4
	return 0;
}

(2)注意事项:

预处理器不做计算,只替换字符序列,因此有:
#include <stdio.h>
#define SQUARE(X) X*X
#define PR(X) printf("The result is %d\n",X); 

int main(void) {
	int x=5;
	PR(SQUARE(x+2));//结果:The result is 17
	PR(100/SQUARE(2));//结果:The result is 100
	return 0;
}
替换过程为:SQUARE(x+2)→X*X→x+2*x+2=5+2*5+2=17与100/SQUARE(2)→100/X*X→100/2*2=100

要解决该问题,需使用足够多的括号以保证运算顺序:
#include <stdio.h>
#define SQUARE2(X) ((X)*(X))
#define PR(X) printf("The result is %d\n",X);

int main(void) {
	int x=5;
	PR(SQUARE2(x+2));//结果:The result is 49
	PR(100/SQUARE2(2));//结果:The result is 25
	return 0;
}

(3)用宏参数创建字符串:

C允许在字符串中包含宏参数.在类函数宏的替换体中,预处理运算符#可以把记号转换成字符串,该过程称为宏参数的"字符串化"(Stringizing):
#include <stdio.h>
#define PSQR(x) printf("The square of " #x " is %d\n",((x)*(x)));
//#x两侧与引号之间的空格也可以没有,不影响结果

int main(void) {
	int y=5;
	PSQR(y);//结果:The square of y is 25
	PSQR(2+4);//结果:The square of 2+4 is 36
	return 0;
}
也就是说,替换体中的#<param>会被替换为"<val>"

3.预处理器连接符:

##运算符把2个记号组合成1个记号:
#include <stdio.h>
#define XNAME(n) x##n
#define PXN(n) printf("x"#n"=%d\n",x##n);

int main(void) {
	int XNAME(1)=1;
	int XNAME(2)=2;
	int XNAME(3)=3;
	PXN(1);//结果:x1=1
	PXN(2);//结果:x2=2
	PXN(3);//结果:x3=3
	return 0;
}
##运算符既可用于类对象宏,也可用于类函数宏

4.变参宏:

C99/C11提供了让用户自定义变参宏(即接受数量可变的参数的宏)的工具,即...和__VA_ARGS__.其中...表示接受数量可变的参数(可以是唯一
的参数),__VA_ARGS__表示...对应的实参要替代的部分,如:
#include <stdio.h>
#define PR(X,...) printf("%d\n",X);printf(__VA_ARGS__);
#define PR2(X,...) printf("%d\n",X);__VA_ARGS__;

int main(void) {
	int x=1;
	PR(x,"aaa\n");
	PR(x,"This is %d\n",3);
	PR2(x);
	PR2(x,printf("%d\n",3));
	return 0;
}
//结果:
1
aaa
1
This is 3
1
1
3

注意:
①...必须是最后1个参数
②...可不对应任何实参

5.宏和函数的选择:

宏和函数的比较:
①宏通常比函数复杂,稍有不慎就会产生奇怪的结果
②宏生成内联代码,即在程序中生成语句,所以调用几次就会产生几份代码,而函数不管调用几次都只有1份代码,也就是说函数比宏节省空间;但调用
函数时,程序的控制必须跳至函数内,执行完毕后再跳回主调函数,这要比宏生成的内联代码花费更多的时间
③此外,宏对变量数据类型的限制更少(因为处理的是文本而不是实际的值).如int/float/double类型的数据均可被传入上文中的SQUARE(X)中,
使用函数则可能导致精度丢失等问题(因为需要进行数据类型的转换)

宏和函数的选择:
①通常用宏来替代那些简单的函数,如:
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
#define ABS(X) ((X)<0?-(X):(X))
#define ISSIGN(X) ((X)=='+'||(X)=='-'?1:0)
②如果希望使用宏来提高性能,需要保证函数被使用足够多次(如在循环尤其是嵌套循环中)才会有明显的效果

三.文件包含
1.语法:

#include <<path_or_filename>>//即头文件名在尖括号中
#include "<path_or_filename>"//即头文件名在双引号中
  //预处理器会用<path_or_filename>中的内容替换#include指令
  //在多数情况下,头文件中的内容是编译器生成最终代码时所需的信息,而不是添加到最终代码中的材料
  //参数说明:
    path_or_filename:指定头文件(包括扩展名.h)
      //使用尖括号表示在标准系统目录(标准库头文件所在的目录)中查找
      //使用双引号表示先查找本地目录,如果没有再在标准系统目录中查找
        //具体先查找哪个目录取决于编译器,可能是当前工作目录/源代码文件所在的目录/项目文件所在的目录...
      //使用双引号并指定路径表示先在指定目录中查找,如果没有再在标准系统目录中查找

//实例:
#include <stdio.h>
#include "F:\1.h"

int main(void) {
	struct name n1={
		"John",
		"Smith"
	};
	printf("I am %s %s.",n1.first,n1.last);//结果:I am John Smith.
	return 0;
}

2.使用头文件:

Ⅰ.常见的内容:
①明示常量    ②类函数宏    ③函数原型声明    ④定义结构体模板    ⑤类型定义

Ⅱ.声明外部变量供其他文件共享

四.其他指令
1.取消宏:

#undef指令用于取消已定义的宏,语法为:
#undef <Macro>
  //即使之前没有定义该宏,也可以使用该命令
  //参数说明:
    Macro:指定要取消的宏

//实例:
#include <stdio.h>
#define AAA 111 

int main(void) {
	printf("%d\n",AAA);//结果:111
	#undef AAA
	#define AAA 222
	printf("%d\n",AAA);//结果:222
	return 0;
}

2.条件编译(Conditional Compilation)

可以使用某些指令创建"条件编译",也就是说,使用这些指令告诉编译器根据编译时的条件执行/忽略某些代码块.这些指令均允许嵌套

(1)#ifdef指令

//语法:
#ifdef <Macro>
<cmd11>
...
[#else
<cmd21>
...]
#endif
  //如果已经定义了<Macro>,则执行<cmd1~>,否则执行<cmd2~>
  //从ANSI C开始支持缩进<cmd1~>/<cmd2~>(下同)
  //参数说明:
    Macro:指定宏
    cmd:指定要执行的命令
      //注意:不一定是预处理指令,也可以是普通的语句如printf()

//实例:
#define AAA 111
#ifdef AAA
    #include <stdio.h>
#endif

int main(void) {
	printf("%d\n",AAA);//结果:111
	return 0;
}
  • 可用于调试程序:
#include <stdio.h>
#define JUST_CHECKING//称为空宏,但该宏也是已定义的
#define LIMIT 4

int main(void) {
    int i,total=0;
    for(i=1;i<=LIMIT;i++) {
        total+=2*i*i+1;
	    #ifdef JUST_CHECKING
    	    printf("%d,%d\n",i,total);
    	#endif
    }
    printf("%d",total);
    return 0;
}
//结果:
1,3
2,12
3,31
4,64
64

调试完成后,去除JUST_CHECKING的定义即可;如果需要再次调试,再加上JUST_CHECKING的定义即可

(2)#ifndef指令:

//语法:
#ifndef <Mcaro>
<cmd11>
...
[#else
<cmd21>
...]
#endif
  //如果尚未定义<Macro>,则执行<cmd1~>,否则执行<cmd2~>
  //参数说明:同上
  • 用于测试:
//arrays.h中:
#ifndef SIZE
    #define SIZE 100
#endif
//main.c中:
#define SIZE 10
#include "arrays.h"

由于在main.c中定义了SIZE,在arrays.h中就不会再定义SIZE.所以可以先在main.c中定义1个较小的数用于测试,测试完毕后取消main.c中的
定义,使用arrays.h中的定义.如果需要再次测试,只需要在main.c中再次定义即可
  • 用于防止多次包含同1个头文件:
//things.h中:
#ifndef THINGS_H_
    #define THINGS_H_
    ...
#endif

如果该文件被包含了多次,其中的命令除第1次外都会由于已经定义了THINGS_H_而被跳过.这种多次包含常常是因为头文件中也会包含其他文件,所以
有些文件已经被隐式包含了.为了保证用于该目的的宏没有在其他地方被定义,这类宏的命名常遵循一定的格式

(3)#if指令与defined运算符:

//defined运算符:
defined <Macro>
  //如果<Macro>已被定义,返回1;否则,返回0

//#if指令:
#if <cond1>
    <cmd11>
      ...
[#elif <cond2>
    <cmd21>
      ...
#else
    <cmdn1>
      ...]
#endif
  //如果满足某个条件,就执行相应的命令;否则执行<cmdn~>

//实例:
#include <stdio.h>
#define IBMPC "IBMPC"
#if defined IBMPC
    #define MAC "MAC"
#else
    #define IBMPC "IBMPC2"
#endif

int main(void) {
    printf("%s\n",IBMPC);//结果:IBMPC
    printf("%s",MAC);//结果:MAC
    return 0;
}

3.预定义宏:

宏含义
__ DATE__预处理的日期,"Mmm dd yyyy"形式的字符串字面量
__ FILE__表示当前文件名的字符串字面量
__ LINE__表示当前源代码行号的整型常量
__ STDC__为1时,表示实现遵循C标准
__ STDC_HOSTED__(C99)本机环境为1,否则为0
__ STDC_VERSION__(C99)如果支持C99标准,为199901L;如果支持C11标准,为201112L
__ TIME__翻译代码的时间,"hh:mm:ss"形式的字符串字面量
#include <stdio.h>

void f(void) {
	printf("%d\n",__LINE__);
}

int main(void) {
    printf("%s\n",__FILE__);
    printf("%s\n",__DATE__);
    printf("%s\n",__TIME__);
    printf("%d\n",__STDC__);
    printf("%d\n",__LINE__);
    f();
    return 0;
}
//实例:
E:\Program\C_C++\1.c
Dec  2 2020
21:53:18
1
11
4

C99还提供了1个名为__func__的预定义标识符,为1个代表当前函数名的字符串.由于__func__具有函数作用域,宏则具有文件作用域,因此__func__
不是预定义宏,而只是预定义标识符:
#include <stdio.h>

void f(void) {
	printf("%s\n",__func__);
}

int main(void) {
    printf("%s\n",__func__);
    f();
    return 0;
}
//结果:
main
f

4.其他预处理器指令
(1)#line指令:

#line用于重置由__LINE__和__FILE__报告的当前行号和文件名:
#include <stdio.h>

int main(void) {
    printf("%s,%d\n",__FILE__,__LINE__);//结果:E:\Program\C_C++\1.c,4
    #line 1000//重置行号
    printf("%s,%d\n",__FILE__,__LINE__);//结果:E:\Program\C_C++\1.c,1000
    #line 2000 "ccc.c"//重置行号和文件名
    printf("%s,%d\n",__FILE__,__LINE__);//结果:ccc.c,2000
    //#line "ddd.c"//不能只重置文件名
    //printf("%s,%d\n",__FILE__,__LINE__);//报错:[Error] ""ddd.c"" after #line is not a positive integer
    return 0;
}

(2)#error指令:

#error指令用于让预处理器发出1条错误信息:
#include <stdio.h>
#define AAA 111
#if AAA==111
    #error Wrong Standard
#endif
//报错:
[Error] #error Wrong Standard

(3)#pragma:

#pragma指令用于把编译器指令放入源代码中.如在开发C99时,标准被称为C9X,可通过以下指令让编译器支持C9X:
#pragma c9x on
另外,编译器一般都有自己的编译指令集,不过C99提供了3个标准编译指示

C99还提供了_Pragma预处理器运算符,用于把字符串转换成普通的编译指示,如:
_Pragma("nonstandardtreatmenttypeB on")
等价于:
#pragma nonstandardtreatmenttypeB on
由于_Pragma不使用#,可以作为宏的替换体的一部分:
#define PRAGMA(X) _Pragma(#X)
_Pragma运算符还会完成"解字符串"(Destringizing)的工作,即把字符串中的转义序列转换为其代表的字符:
_Pragma("use_bool \"true \"false")
被转换为了:
#pragma use_bool "true "false

5.泛型:

在编程设计中,"泛型编程"(Generic Programming)指那些没有特定类型,但一旦指定1种类型,就可以转换为指定类型的代码.C没有这种功能,但C11
新增了"泛型选择表达式"(Generic Selection Expression),可根据表达式的类型(int/double等)选择1个值.泛型选择表达式不是预处理器指
令,但在一些泛型编程中常用作宏定义的一部分

//语法:
_Generic(<var>,<type1>:<val1>,<type2>:<val2>...)
  //如果<var>是<typei>类型的变量,那么整个表达式的值就是<vali>
  //参数说明:
    var:指定表达式
    type:指定数据类型,如int/float
      //注意:外面没有双引号,即不是str
      //default表示其他<type>中没有的类型
    val:指定该数据类型对应的值

//实例:
#include <stdio.h>
#define MYTYPE(x) _Generic(x,int:"int",float:"float",double:"double",default:"other")

int main(void) {
	int x=5;
	printf("%s\n",MYTYPE(x));//结果:int
	printf("%s\n",MYTYPE(2.0*x));//结果:double
	printf("%s\n",MYTYPE(3L));//结果:other
	printf("%s\n",MYTYPE(&x));//结果:other
	printf("%s\n",MYTYPE('a'));//结果:int
	printf("%s\n",MYTYPE("aaa"));//结果:other
	return 0;
}
EdVzAs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言——预处理
qq_42437056的博客
08-16 145
在预处理之前，编译器必须对程序进行一些翻译处理， 编译器把源代码中出现的字符映射到源字符集 编译器定位每个反斜杠后面跟着换行符的实例，并删除它们（可以把两个物理行转化为一个逻辑行） 编译器把文本划分为预处理记号序列、空白序列和注释序列（编译器将用一个空格字符替换每一条注释） 宏 预处理器发现程序中的宏后，会用宏等价的替换文本进行替换。如果替换的字符串中还包含宏，则继续替换这些宏，唯一例外的是双引号中的宏。 类函数宏与函数（宏和函数的选择是时间和空间的权衡） 宏调用是字符串替换，在编译之前把参数记号传递给程序
C语言也可以实现泛型（转）
weixin_44001521的博客
10-18 1099
原文地址：https://www.cnblogs.com/wuyudong/p/c-general-function1.html #include<string.h> #include<stdio.h> // C 语言也可以实现一定的泛型编程，但这样是不安全的，系统对其只有有限的检查。在编程时一定要多加细心。 /*变量是不能声明为 void 无类型的。而你不知道调用此函数传进的参数是什么类型的，无法确定一种类型的声明。 同时，不能将 * 用在无类型指针上，因为系统没有此地址指向对象大
预处理标识符简单介绍
z517602658的博客
11-04 382
__FILE__   //进行编译的源文件 __LINE__   //文件当前的行号 __DATE__  //文件被编译的日期 __TIME__    //文件被编译的时间 __STDC__   //如果编译器遵循ANSI C，其值为1，否则未定义 下面我们给出一个宏函数示例#include #define PRINT_DEBUG printf("%s %d %s %s %d\n",
编程学习(三)----预处理器指示符
重展羽翼
02-18 331
在前一篇提到了一串字符#include，这串字符就是预处理器指示符，它用“#”来标识。而处理这些指示符的程序被称做预处理器（通常捆绑在编译器中）。#include读入文件有两种格式： #include表明这个文件是一个工程或标准头文件，查找过程会检查预定义的目录 #include”some_file.h”表明该文件是用户提供的头文件，查找该文件时将从当前文件目录开始 被包含的文件还可以含有#
预处理器 - 记号传递操作符##
闲云孤鹤
08-14 1037
原文译至：http://complete-concrete-concise.com/programming/c/preprocessor-the-token-pasting-operator ##可能是最不为人所知，也最缺少文档的预处理器操作符了。 记号传递操作符(##) 仅仅删除它周围的所有空格和将非空的字符连接到一起。它只能用于一个宏定义中，它被用于创建新的记号。 它不能是替换文本里
CPP.zip_decus_预处理器
09-23
DECUS C预处理器可能包含了特定的扩展或优化，以适应DECUS C语言环境。例如，可能提供了特定的宏定义、条件编译指令或者处理 DECUS 特有的编译标志。不过，由于具体细节没有给出，这部分内容只能通过查阅 DECUS 的...
c语言快速入门.doc
09-28
`#include`预处理器指令用于将指定的头文件内容插入到源代码中。`stdio.h`是标准输入输出库，包含了像`printf`、`scanf`等常用的输入输出函数。通过右键点击`printf`等函数，可以查看其定义，理解其工作原理。 3. ...
C语言中宏定义使用的小细节
09-05
这种方式告诉预处理器不要将`(isalpha)`视为宏，而是将其解释为函数调用。这在你知道某个宏已经被定义，但希望使用函数版本时特别有用。 使用函数而非宏定义的好处在于，函数会进行类型检查，可以防止类型不匹配...
C.zip_C语言
09-23
3. **预处理器**：C语言具有预处理器，可以进行宏定义、条件编译等操作，方便代码复用和条件执行。 4. **函数**：C语言通过函数实现模块化，函数可以接受参数并返回值，支持递归调用。 5. **内存管理**：程序员可以...
C语言深入解析.rar
09-14
预处理器可以完成文本替换、条件编译等功能，宏定义则可以创建简单的函数替代或常量定义。 7. **专题七**：动态内存分配（malloc/free）和内存管理是C语言高级主题。理解如何在运行时动态分配和释放内存，可以避免...
预处理标识符及宏与函数的区别
hm108106的博客
11-06 452
1.预处理标识符（在程序预处理阶段会被全部替换）                预处理标识符                     作用                            __LINE__     当前源程序的行数               __FILE__     当前源程序的路径
C语言之编译预处理
qq_51196701的博客
12-30 4354
编译预处理是指在c编译程序对c源程序进行编译之前，对预处理命令进行“预先“处理的过程。编译预处理是通过编译预处理程序实现的。 预处理命令不是c语言的组成部分，c语言的编译程序无法识别他们。 比如#include<stdio.h>就是一个预处理命令，其功能是在将源程序编译成目标程序之前，将文件“stdio.h“中的内容替换该命令，然后由编译程序将源程序翻译成目标程序。 C语言中的预编译处理命令主要有以下3种：宏定义、文件包含、条件编译 为了与一般的c语句相区分，编译预处理命令必须以#为
【为什么】C++中的宏
最新发布
C++十万个为什么
03-24 1320
C++宏的简单理解 C++中的宏是一种代码片段，可以被宏的值所替换。宏是用#define指令来定义的，用#undef指令来取消定义。宏有两种类型：类对象宏和类函数宏。 类对象宏就像一个常量，只不过不需要分配内存空间。 类函数宏就像一个函数，只不过不需要调用和返回。 大白话来说，宏就是一种让你写代码时更方便、更简洁、更灵活的工具 举例说明 假设你想定义一个宏，用来计算两个数的最大值。你可以这样写：...
【C语言】程序的编译与预处理操作
DanteKing的博客
08-19 1549
0. 目录 1.摘要 2.翻译过程         2.1总述         2.2预处理         2.3编译         2.4链接 3.执行过程 4.预处理指令         4.1 预定义符号         4.2 #define定义标识符 &nb
字符型和字符串型的对比
热门推荐
章飞 _906285288的博客
12-21 1万+
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
C预处理器和C库（C语言学习笔记）
weixin_46429500的博客
12-06 585
本章主要内容： 预处理指令——#define、#include、#ifdef、#else、#endif、#ifndef、#if、#elif、#line、#error、#pragma; 关键字—— _Generic、 _Noreturn、 _Static _assert; 函数/宏——sqrt()、atan()、atan2()、exit()、atexit()、assert()、memcpy()、memmove()、va_start()、va_arg()、va_copy()、va_e.
字符与字符串详解
qq_46804966的博客
03-07 1万+
文章目录1.什么是字符2.什么是字符串3.字符数组与字符串3.1字符数组-->字符串3.2字符串-->字符数组4.字符串的其他方法5.字节数组与字符串6.小结 1.什么是字符 字符类型char是基本数据类型，它是character的缩写。一个char保存一个Unicode字符 char c = 'a'; char d = '1'; char e = '*'; 2.什么是字符串 和char类型不同，字符串类型String是引用类型，我们用双引号"…
c++预处理器概述 #define #ifdef #ifndef #endif
春风来不来的博客
10-22 1971
预处理器： 确保头文件多次包含仍能安全工作，即可以有效地防止头文件重复包含的发生.
宏定义#define的一些总结
newbeixue的博客
12-16 372
https://blog.csdn.net/qq_41071068/article/details/92805050 类对象宏(无参宏), 即宏名之后不带参数，只是简单的文本替换 其定义的一般形式为： #define 标识符 字符串 #define N 10 类函数宏(带参数的宏) C/C++允许宏带有参数。 带参数的宏定义，宏名中不能有空格，宏名与形参表之间也不能有空格，而形参表中形参之间可以有空格, 在行末不必加分号，如加上分号则在预处理时连分号也一起添加到代码中。 约定 : 一般来说函数和类函数宏使
C预处理器详解：GCC 11.1.0版及其工作原理
C预处理器是C语言编译过程中的一个关键组件，它在源代码编译之前对文本进行处理，以执行宏定义、条件编译、包含头文件等功能。本文档主要针对GCC版本11.1.0，由Richard Stallman和Zachary Weinberg撰写，版权归属...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值