19、宏定义使用分析

宏开始给我的两个印象：1、可以用来定义常量 2、定义代码块

1、C语言中的宏定义

— #define 是预处理器处理的单元实体之一
— #define 定义的宏可以出现在程序的任意位置
— #define 定义之后的代码都可以使用这个宏

2、定义宏常量

— #define 定义的宏常量可以直接使用
— #define 定义的宏常量本质为字面量

#include <stdio.h>
#define ERROE -1
#define PATH1 "D:\test\test.c"
#define PATH2 D:\test\test.c
#define PATH3 D:\test\
test.c
int main()
{
	int eer = ERROR;
	char* p1 = PATH1;
	char* p2 = PATH2;		//error
	char* p3 = PATH3;		//error
	return 0;
}

这个程序宏定义是正确的，但是编译过不了，不符合代码的规范。

3、宏定义表达式

— #define 表达式的使用类似于函数调用
— #define 表达式可以比函数更强大
— #define 表达式比函数更容易出错

#include <stdio.h>
#define _SUM_(a,b) (a)+(b)
#define _MIN_(a,b) (a)<(b)?(a):(b)
#define _DIM_(a) sizeof(a)/sizeof(*a)

int main()
{
	int a = 1;
	int b = 2;
	int c[4] = { 0 };

	int s1 = _SUM_(a, b);
	int s2 = _SUM_(a, b)*_SUM_(a, b);
	int m = _MIN_(a++, b);
	int d = _DIM_(c);

	printf("s1 = %d\n", s1);		//1+2 = 3
	printf("s2 = %d\n", s2);		//1+2*1+2  = 5
	printf("m = %d\n", m);		//(a++)<(b)?(a++):(b)  2
	printf("a = %d\n", a);
	printf("d = %d\n", d);		//4

	return 0;
}

这个程序体现出了宏的弊端，宏是被预处理器定义的，直接进行文本替换，得到的结果和我们的预期结果发生误差。

4、宏表达式和函数进行对比

— 宏表达式被预处理器处理，编译器不知道宏表达式的存在，函数是被编译器处理，完全没有可比性
— 宏表达式用“实参”完全替代形参，是一种文本替换，不进行任何运算
— 优势：宏表达式没有任何的“调用”开销，函数需要参数的入栈和出栈，都是调用开销
— 宏表达式中不能出现递归定义

#include <stdio.h>
//#define _SUM_(n) ((n > 0) ? (_SUM_(n - 1) + n):0)		//error
int _SUM_(int n)
{
	return ((n > 0) ? (_SUM_(n - 1) + n):0);
}
int main()
{
	int s = _SUM_(10);
	printf("s = %d\n", s);

	return 0;
}

根据这个程序我们知道所以宏定义不能代替递归，毕竟就单纯一个文本替换，怎么可能一直进行递归，所以递归最好还是用函数。

4、提出问题：宏定义的常量或者表达式是否有作用域限制？

#include <stdio.h>

void def()
{
	#define PI 3.1415926
	#define AREA(r) r*r*PI
}
double area(double r)
{
	return AREA(r);           // 提出问题，一个函数返回里一个函数的值，到底合不合理？
}
int main()
{
	double s = area(5);

	printf("PI = %f\n", PI);
	printf("s = %f\n", s);

	return 0;
}

这个程序没有报错并且运行成功，因此我们可以得出结论，对于宏而言，是没有作用域的限制，当我们定义完宏，后面的代码就可以直接使用。
作用域的概念是针对C语言里面的变量和函数，不针对宏，因为宏是被预处理器处理的，我们的编译器根本不知道宏的存在，所以编译器无法将作用域的概念应用于标识符。

5、强大的内置宏

#include <stdio.h>
#include <malloc.h>

#define Malloc(type,n) (type *)malloc(sizeof(type)*n)
#define Free(p) (free(p),p = NULL)

#define Log(s) printf("[%s] {%s:%d} %s \n",__DATE__,__FILE__,__LINE__,s)

#define FOREACH(i,n) for(i = 0;i<n;i++)

#define Begin {
#define End }
int main()
{
	int i = 0;
	int* p = Malloc(int, 5);
	Log("xiebs nb!");
	FOREACH(i, 5)
	Begin
		p[i] = i;
	End

	FOREACH(i, 5)
	Begin
		printf("p[i] = %d\n", p[i]);
	End

	Free(p);
	Log("End");
	return 0;
}

这个程序主要是用内置宏和基本的一些宏定义来写的，宏的优点在于效率高。