第46课

第46课 - 函数与宏分析

1. 函数与宏

（1）宏是由预处理器直接替换展开的，编译器不知道宏的存在，因此参数无法进行类型检查

        函数是由编译器直接编译的实体，调用行为由编译器决定

（2）多次使用宏会增大代码量，最终导致可执行程序的体积增大，对于嵌入式设备而言，设备资源有限，这个还是比较重要的

        函数是跳转执行的，内存中只有一份函数体存在，不存在宏的问题

（3）宏的效率比函数高，因为宏是文本替换，没有调用开销       //  虽然宏的效率比函数稍高但副作用很大，因此，可以用函数完成的功能绝对不用宏

        函数调用会创建活动记录，效率不如宏

（4）函数可以递归调用，但宏的定义中不能出现递归定义

【函数与宏】

#include <stdio.h>

// 使用宏将一片内存区域置0
#define RESET(p, len) while(len > 0) 
                        ((char *)p)[--len] = 0

// 使用函数将一片内存区域置0
void reset(void *p, int len)
{
    while(len > 0)
        ((char *)p)[--len] = 0;

}

int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int len = sizeof(a); 
    int i = 0;

    /*
        下面的宏和函数都可以实现置0的功能
        但是假如使用 RESET(10, len)，这个在编译期间是不错报错的，宏不会检查参数的类型
        使用reset(10, len)函数在编译时就会有warning，提示传参类型不符
    */
    // reset(a, len);
    // RESET(a, len);

    for(i = 0; i < 5; i++) {
        printf("a[%d] = %d
", i, a[i]);
    }

    return 0;
}

【宏的副作用】

#include <stdio.h>

#define _ADD_(a, b) a + b
#define _MUL_(a, b) a * b
#define _MIN_(a, b) ((a) < (b) ? (a) : (b))

int main()
{
    int i = 1;
    int j = 10;

    // 预处理结果：printf("%d
", 1 + 2 * 3 + 4);
    // 预期： (1 + 2) * (3 + 4) ==> 21
    // 实际： 1 + 2 * 3 + 4 ==> 11
    printf("%d
", _MUL_(_ADD_(1, 2), _ADD_(3, 4)));  

    // 预处理结果：printf("%d
", ((i++) < (j) ? (i++) : (j)));
    // 预期： 1 < 10? 1 : 10 ==> 1
    // 实际： (i++) < (j) ? (i++) : (b) ==> 2
    printf("%d
", _MIN_(i++, j));  
                                    
    return 0;
}

2. 宏的妙用 

 前面讲了宏的很多副作用和缺点，那宏是不是一无是处呢？绝对不是这样的，在C语言中宏有很多妙用。

（1）用于生成一些常规性的代码，比如下面代码中的LOG_INT、LOG_CHAR、LOG_FLOAT、LOG_POINTER

（2）封装函数，加上类型信息，比如下面代码中的MALLOC的实现

【宏的妙用】

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

#define MALLOC(type, x)  (type*)malloc(sizeof(type) * x)
#define FREE(p)          (free(p), p = NULL)

#define LOG_INT(i)        printf("%s = %d
", #i,  i)
#define LOG_CHAR(c)       printf("%s = %c
", #c,  c)
#define LOG_FLOAT(f)      printf("%s = %f
", #f,  f)
#define LOG_POINTER(p)    printf("%s = %p
", #p,  p)
#define LOG_STRING(s)     printf("%s = %s
", #s,  s)

#define FOREACH(i, n)    while(1){ int i = 0, l = n;for(i = 0; i < l; i++)    // 使用while是为了定义一个scope，局部变量都在其中
#define BEGIN            {
#define END              }break;}

int main()
{
    int* pi = MALLOC(int, 5);  // ①可以指定数据类型，代码可读性更强 ②返回的void *指针已经进行了强制类型转换
    char* str = "2020-01-14 22:38:27";

    LOG_STRING(str);  // str = 2020-01-14 22:38:27

    LOG_POINTER(pi);  // pi = 0x74f010

/*
    while(1){ int k = 0, l = 5;for(k = 0; k < l; k++)
    {
        pi[k] = k + 1;
    }break;}
*/
    FOREACH(k, 5)
    BEGIN
        pi[k] = k + 1;  // 对pi对应的堆空间赋值
    END

/*
    while(1){ int k = 0, l = 5; for(k = 0; k < l; k++)
    {
        int value = pi[k];
        printf("%s = %d
", "value", value);
    }break;}
*/
    FOREACH(k, 5)
    BEGIN
        int value = pi[k];  // 遍历pi对应的堆空间
        LOG_INT(value);    
    END

    FREE(pi);   // 安全的释放动态内存

    LOG_POINTER(pi);    // pi = nil

    return 0;
}