预处理详情

#include <stdio.h>
int main()
{
	printf("%s\n", __FILE__);
	printf("%d\n", __LINE__);
	printf("%s\n", __DATE__);
	printf("%s\n", __TIME__);
//	printf("%s\n", __STDC__);

	return 0;
}

当我们把这个注释掉其他的打印内容会是什么样的呢？

2. #define 定义常量

#define name stuf

#define MAX 1000
#define reg register //为 register这个关键字，创建⼀个简短的名字
#define 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定义标识符的时候，要不要在最后加上 ; ? ⽐如：

efine MAX 1000;

#define MAX 1000#d

如果是加了分号的情况，等替换后，if和else之间就是2条语句，⽽没有⼤括号的时候，if后边只能有⼀条语句。这⾥会出现语法错误。

3. #define定义宏

#define 机制包括了⼀个规定，允许把参数替换到⽂本中，这种实现通常称为宏（macro）或定义宏（define macro）。下⾯是宏的申明⽅式：

#define name( parament-list ) stuff

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

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

定义一个宏，数的平方

#define QUT(n) n*n
int main()
{
	int a = 0;
	scanf("%d", &a);
	int ret = QUT(a);
	printf("%d ", ret);


	return 0;
}

这个宏接收⼀个参数 x .如果在上述声明之后，你把 SQUARE( 5 ); 置于程序中，预处理器就会⽤下⾯这个表达式替换上⾯的表达式： 5 * 5

警告：这个宏存在⼀个问题：观察下⾯的代码段：

你可能觉得这段代码将打印36，事实上它将打印11，为什么呢？替换⽂本时，参数x被替换成a + 1,所以这条语句实际上变成了

#define SQU(n) n*n //这里是把5+1 都传入n中，5+1 *5+1=11
int main()
{
	
	int ret = SQU (5 + 1);
	printf("%d ", ret);

	return 0;

如果想要这个的结果变成36 只需把5+1 添加括号

#define SQU(n) (5+1)*(5+1)
int main()
{

   int ret = SQU(5 + 1);
   printf("%d ", ret);

   return 0;
}

4. 带有副作⽤的宏参数

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

x+1;//不带副作⽤

x++;//带有副作⽤

define MAX(a, b) ((a) > (b) ? (a) : (b))
...
x = 5;
y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？

z = ( (x++) > (y++) ? (x++) : (y++));

所以输出的结果是：x=6 y=10 z=9

5. 宏替换的规则

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

1. 在调⽤宏时，⾸先对参数进⾏检查，看看是否包含任何由#define定义的符号。如果是，它们⾸先被替换。

2. 替换⽂本随后被插⼊到程序中原来⽂本的位置。对于宏，参数名被他们的值所替换。

3. 最后，再次对结果⽂件进⾏扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意： 1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

6. 宏函数的对⽐

宏通常被应⽤于执⾏简单的运算。

⽐如在两个数中找出较⼤的⼀个时，写成下⾯的宏，更有优势⼀些。

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

那为什么不⽤函数来完成这个任务？原因有⼆：

1. ⽤于调⽤函数和从函数返回的代码可能⽐实际执⾏这个⼩型计算⼯作所需要的时间更多。所以宏⽐函数在程序的规模和速度⽅⾯更胜⼀筹。

2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使⽤。反之这个宏怎可以适⽤于整形、⻓整型、浮点型等可以⽤于 > 来⽐较的类型。宏的参数是类型⽆关的。

和函数相⽐宏的劣势：

1. 每次使⽤宏的时候，⼀份宏定义的代码将插⼊到程序中。除⾮宏⽐较短，否则可能⼤幅度增加程序的⻓度。

2. 宏是没法调试的。

3. 宏由于类型⽆关，也就不够严谨。

4. 宏可能会带来运算符优先级的问题，导致程容易出现错。宏有时候可以做函数做不到的事情。⽐如：宏的参数可以出现类型，但是函数做不到。

#define MALLOC(num, type)\
(type )malloc(num sizeof(type))
...
//使⽤
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int*)malloc(10 sizeof(int));

宏和函数的⼀个对⽐

7. #和##

7.1 #运算符

#运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。 #运算符所执⾏的操作可以理解为”字符串化“

当我们有⼀个变量 int a = 10; 的时候，我们想打印出： the value of a is 10 . 就可以写：

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

当我们按照下⾯的⽅式调⽤的时候： PRINT(a);//当我们把a替换到宏的体内时，就出现了#a，⽽#a就是转换为"a"，时⼀个字符串

printf("the value of ""a" " is %d", a)

7.2 ## 运算符

## 可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的⽂本⽚段创建标识符。 ## 被称为记号粘合这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的。这⾥我们想想，写⼀个函数求2个数的较⼤值的时候，不同的数据类型就得写不同的函数。

int int_max(int x, int y)
{
return x > y ? x : y;
}
float float_max(float x, float y)
{
return x > yx:y;
}

但是这样写起来太繁琐了，现在我们这样写代码试试：

//宏定义
#define GENERIC_MAX(type) \ 续航符
type type##_max(type x, type y)\
{ \
return (x>y?x:y); \
}

GENERIC_MAX(int) //替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名
GENERIC_MAX(float) //替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名
int main()
{
   //调⽤函数
   int m = int_max(2, 3);
   printf("%d\n", m);
   float fm = float_max(3.5f, 4.5f);
   printf("%f\n", fm);
   return 0;
}

8. 命名约定

把宏名全部⼤写

函数名不要全部⼤写

9. #undef

这条指令⽤于移除⼀个宏定义

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

#define  M 10
int main()
{

	int a = M;
#undef M  //要取消的名字
	int b = M;

	return 0;
}

10. 命令行定义

许多C 的编译器提供了⼀种能⼒，允许在命令⾏中定义符号。⽤于启动编译过程。

#include <stdio.h>
int main()
{
   int array[ARRAY_SIZE];
   int i = 0;
   for (i = 0; i < ARRAY_SIZE; i++)
   {
       array[i] = i;
   }
   for (i = 0; i < ARRAY_SIZE; i++)
   {
       printf("%d ", array[i]);
   }
   printf("\n");
   return 0;
}

编译指令：

//linux 环境演⽰

gcc -D ARRAY_SIZE=10 programe.c

11. 条件编译

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

11.1#if

#if 常量表达式

//... #endif

int main()
{
#if 0
	printf("haha\n");

	printf("%d ",100);


	return 0;
 }
#endif//如果把#endif放在最后相当于被注释掉了。

#if 常量表达式

//... #elif 常量表达式

//... #else

//... #endif

2.多个分⽀的条件编译

#define M 5
int main()
{
#if M == 1
	printf("nihao ");
#elif M== 2
	printf("haoya ");
#elif  M== 4
	printf("nn ");
#else  M== 5
	printf("%d ",100);
#endif

	return  0;
}

3.判断是否被定义

#if defined(symbol)

#ifdef symbol

#if !defined(symbol)

#ifndef symbol

#define ZHANGSAN 
int main()
{
#ifdef EHANGSAN
	printf("ZHANGSAN\n");
#endif
	printf("WANGWU\n ");

	return 0;
}

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

12. 头⽂件的包含

12.1.本地⽂包含

#include "filename"

Linux环境的标准头⽂件的路径：

1 /usr/include

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

12. 2 库⽂件包含

查找头⽂件直接去标准路径下去查找，如果找不到就提⽰编译错误。这样是不是可以说，对于库⽂件也可以使⽤ “” 的形式包含？答案是肯定的，可以，但是这样做查找的效率就低些，当然这样也不容易区分是库⽂件还是本地⽂件了。

12.3嵌套⽂件包含

#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{

return 0;
}

如果直接这样写，test.c⽂件中将test.h包含5次，那么test.h⽂件的内容将会被拷⻉5份在test.c中。如果test.h ⽂件⽐较⼤，这样预处理后代码量会剧增。如果⼯程⽐较⼤，有公共使⽤的头⽂件，被⼤家都能使⽤，⼜不做任何的处理，那么后果真的不堪设想。如何解决头⽂件被重复引⼊的问题？答案：条件编译

#ifndef __TEST_H__
#define __TEST_H__
//头⽂件的内容
#endif //__TEST_H//防止头文件被多次包含的。

或者

#pragma once //头文件只会包含一次

就可以避免头⽂件的重复引⼊。

到这里c语言就结束了，希望越学越幸运。

撒花完结！！！！

标签：__,return,定义,int,详情,printf,预处理,define
From： https://blog.csdn.net/2402_82715436/article/details/143201053

1. 预定义符号