Biegral Blog

一、#define

1、仅仅作为标识符：

    #define作为标识符时是没有参数的

2、作为宏：

    #define 作为宏与它作为标识符的区别就是宏有参数而标识符没有

    例如：#define MAX（X,Y） ((X)>(Y)?(X):(Y))

二、宏与函数的区别

1、宏在使用时（编译阶段）会直接被替换掉（即简单的代码复制），并且不会进行逻辑检测

2、在对代码调试时，不能进入内部调试，执行后就直接回产生值。而函数与此不同

3、宏在进行定义时不会考虑参数的类型（但这不安全）

4、宏会产生带副作用的宏参数

      请分析下面这段代码：

#include<stdio.h>
#include<stdlib.h>
 
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
 
int main()
{
    int a = 10;
    int b = 20;
    int ret = MAX(a++,b++);//int ret = MAX(a++,b++) ((a++)>(b++)?(a++):(b++))
    printf("a=%d,b=%d,ret=%d\n",a,b,ret);
    system("pause");
    return 0;
}

  其产生的结果为：a=11，b=22，ret=21

  产生这种结果的原因就是宏被替换后产生了带副作用的参数，a被执行了一次，b被执行了两次

5、参数宏的运行速度比函数快，因为它只是简单的替换，不需要参数压栈/出栈操作

6、宏在定义时要尽量多加括号

     例如：在宏定义中 #define DOUBLE(X,Y) X*Y  ，如果使用时给的参数是

           （5+5,5+5）,运行的结果就会出错。

7、宏可以将类型作为参数，而函数却不可以  （关于动态内存开辟）

用函数动态开辟一块空间：

int main()
{
    int *p=(int *)malloc(10*sizeof(int));
    int i=0;
    for(; i<10; i++)
    {
        p[i]=i;
    }
    for(i=0; i<10; i++)
    {
        printf("%d ",p[i]);
    }
    free(p);
    system("pause");
    return 0;
}

缺点：有可能会开辟内存失败。例如：int *p=(int *)malloc(0xffffffff);

      0xffffffff  是所有内存地址编码的集合，即为所有内存，这种情况下，开辟内存就会失败，所       以在用 malloc（）函数后还应该对指针 p 进行判断

int i=0;
int *p=(int *)malloc(10*sizeof(int));
if(p == NULL)
{
    printf("put of memory!\n");
    exit(1);      //结束程序
}

而利用宏来开辟内存就会省掉这些麻烦：

#define MALLOC(COUNT,TYPE) (TYPE*)alloc(COUNT*sizeof(TYPE))
void *alloc(int sz)
{
    void *p=malloc(sz);
    if(p == NULL)
    {
        printf("out of memory!\n");
    }
    return p;
}
 
int main()
{
    int *p=MALLOC(10,int);
    int i=0;
    for(; i<10; i++)
    {
        p[i]=i;
    }
    for(i=0; i<10; i++)
    {
        printf("%d ",p[i]);
    }
    free(p);                //动态开辟后一定要释放这些内存，否则会发生内存泄漏
    system("pause");
    return 0;
}

 

    开辟内存时只要传进类型就ok了  

 

8、宏不可以递归，函数可以

#define MAX(X,Y) ((X)>(Y)?(X):(Y))
#define M 100
 
int main()
{
    int ret = MAX(MAX(M,20),200);    //这是嵌套使用，不是递归
    return 0;
}

9、函数只在目标文件中存在一处，比较节省空间

10、宏进行定义时，名字与参数之间不能有空格分开，但使用时可以有