当前位置：网站首页>预处理指令

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

举个栗子：

#include<stdio.h>
int main()
{
	printf("file:%s line:%d\n", __FILE__, __LINE__);
	return 0;
}
//结果:file:D:\代码\预处理指令与宏\源.c line : 12

2.#define 定义标识符

//标识符和我们下面讲到的宏都只做文本的替换
#define MAX 1000
//标识符常量
#define MAX 1000;
//定义标识符时，后面不要写;可能会出现语法错误
#define MAX 1000
#define condition MAX>0;
if (condition)
	max = MAX;
else
	max = 0;
//在这里由于替换的部分包含;就变成了如下代码，这时语法也就错误了
if (1000>0;)
	max = 1000;
else
	max = 0;


#define reg register
//为 register这个关键字，创建一个简短的名字
#define do_forever for(;;)
//用更形象的符号来替换一种实现
#define CASE break;case
//在写case语句的时候自动把 break写上。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
date:%s\ttime:%s\n" ,\
__FILE__,__LINE__ , \
__DATE__,__TIME__ )
//如果定义的 stuff过长，可以分成几行写
//除了最后一行外，每行的后面都加一个反斜杠(续行符)
//这个符号只做换行使用，不会被读取为字符。

3.#define定义宏

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

下面是宏的申明方式：#define name( parament-list ) stuff

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

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

#include<stdio.h>
#define MULTIPLE(X) X*X
//宏先传递参数10，然后将原来宏部分替换为10*10
//宏不会进行计算，表达式结果最后由程序计算
int main()
{
	int a = 10;
	printf("%d", MULTIPLE(a));
	return 0;
}
//结果：100

然而这样的定义是有问题的

#include<stdio.h>
#define MULTIPLE(X) X*X
int main()
{
	printf("%d", MULTIPLE(5+1));
	return 0;
}
//结果：11

我们想要计算6的平方，结果却不对。这是因为宏只会替换，MULTIPLE(5+1)被替换为5+1*5+1，计算后结果当然等于11了

所以我们在定义宏时，各个部分和整体都要加上括号，总之在宏定义上不要吝啬括号

#include<stdio.h>
#define MULTIPLE(X) ((X)*(X))
int main()
{
	printf("%d", MULTIPLE(5 + 1));
	return 0;
}
//结果：36

二、#与##

1.#

#include<stdio.h>
#define VALUE(A) printf("the value of "#A" is %d\n",A)
int main()
{
	//printf这个函数可以打印多个字符串
	//实现一个宏打印the value of 变量名 is 变量值
	int a = 1;
	VALUE(a);
	int b = 2;
	VALUE(b);
	VALUE(b+1);
	return 0;
}
//printf("the value of "#A" is %d\n", A)
//#A表示把A这个变量名转换为一个字符串
//VALUE(a);经过替换后：printf("the value of ""a"" is %d\n",a);也就能完成任务
//结果：the value of a is 1
//the value of b is 2
//the value of b+1 is 3

2.##

#define ADD_TO_SUM(num, value) \
sum##num += value;
int main()
{
	int sum5 = ADD_TO_SUM(5, 10);//作用是：给sum5增加10.
	printf("%d", sum5);
	return 0;
}
//ADD_TO_SUM(num, value) sum##num += value;
//这里的num和value先进行替换，变为sum##5 += 10;
//然后##将sum和5合并起来，变为sum5 += 10;

这两个指令符号基本上不会用到，看到认识就行

三、宏和函数

1.带有副作用的宏参数

#include<stdio.h>
#define MAX(a,b) ((a)>(b)?(a):(b))
int main()
{
	int x = 5;
	int y = 8;
	int z = MAX(x, y);
	printf("x=%d y=%d z=%d\n", x, y, z);
	//替换：int z = ((5)>(8)?(5):(8))
	//结果：x=5 y=8 z=8
	z = MAX(x++, y++);
	printf("x=%d y=%d z=%d\n", x, y, z);
	//替换：int z = ((5++)>(8++)?(5++):(8++))
	//第一步比较大小：5<8,结果为假，同时5和8加一，((6)>(9)?(6++):(9++))
	//取后值9++，先使用赋值z为9，原数据后加一为10
	//结果：x=6 y=10 z=9
	return 0;
}

2.宏的优势和缺点

宏的优点：

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

宏的缺点：

每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
宏是没法调试的。
宏由于类型无关，也就不够严谨。
宏可能会带来运算符优先级的问题，导致程容易出现错。

3.宏和函数的对比

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

四、条件编译

1.条件编译指令

1.基本条件编译
#if 常量表达式
//...
#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

2.举例

#include<stdio.h>
#define DEBUG
#define A
#define B 1
int main()
{
#ifdef DEBUG
	printf("hello world\n");
#endif // DEBUG
//如果DEBUG被定义就进行编译

#undef A
//移除定义的A
#ifndef A
	printf("haha\n");
#endif // !A
//如果A没被定义就进行编译
	
#if B == 1
	printf("hhhhh\n");
#elif B == 2
	printf("wwwww\n");
#else
	printf("rrrrr\n");
#endif
	//类似于if、else语句，表达式判断为真的时候就会编译内部的内容
	return 0;
}

五、文件包含

1.#include

我们已经知道， #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。这种替换的方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。这样一个源文件被包含10次，那就实际被编译10次

在前面加上#pragma once就会对重复的头文件只包含一次

#ifndef A
    define A
    include<stdio.h>
#endif
//这样也可以

2.#include "filename"与#include

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

#include "filename"程序查找头文件会先去程序的默认文件夹下寻找，然后去C语言内置的库中寻找。

#include 会直接去C语言内置的库中寻找。

其实，对于库文件也可以使用 ""的形式包含。但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件。

总结：其实C语言还有很多的预处理指令，如#error、#pragma、#line等，我们可以去细细了解

C语言部分结束

原网站

版权声明
本文为[聪明的骑士]所创，转载请带上原文链接，感谢
https://blog.csdn.net/qq_65285898/article/details/125976686