项目开发中用到的一些宏定义总结(不定时更新)

最新推荐文章于 2024-08-16 11:23:13 发布

I_O_fly

最新推荐文章于 2024-08-16 11:23:13 发布

阅读量307

点赞数

分类专栏： C语言项目开发

本文链接：https://blog.csdn.net/I_O_fly/article/details/102950039

版权

C语言项目开发专栏收录该内容

5 篇文章 0 订阅

订阅专栏

#ifdef DEBUG   

#define DBG(...) fprintf(stderr, " DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); fprintf(stderr, __VA_ARGS__)  

#else   

#define DBG(...)   

#endif  



int main()  

{  

DBG("hello\n");  

}

/*C语言预处理器定义的一些宏 

__LINE__  当时行号（预处理器正在执行的那一时刻），十进制数 

__FUNCTION__ 当时函数，字符串 

__FILE__当时文件，字符串 

__DATE__当时日期，字符串 

__TIME__当时时间，字符串 

等 

*/

如果在gcc ,use -D define DEBUG micro

[root@localhost test]# gcc -o test1 test1.c -DDEBUG

[root@localhost test]# ./test1

DBG(test1.c, main(), 11): hello // 这行为打印的内容，后面的hello为程序DBG("hello\n");中的hello。

#、##、 …和_ VA_ARGS _
1.#
　　假如希望在字符串中包含宏参数，ANSI C允许这样作，在类函数宏的替换部分，#符号用作一个预处理运算符，它可以把语言符号转化程字符串。例如，如果x是一个宏参量，那么#x可以把参数名转化成相应的字符串。该过程称为字符串化（stringizing）.简单理解就是:#n把一个宏参数n变成字符串n

#incldue <stdio.h>
#define PSQR(x) printf("the square of" #x "is %d.\n",(x)*(x))
int main(void)
{
    int y =4;
    PSQR(y);
    PSQR(2+4);
    return 0;
}

输出结果：
the square of y is 16.
the square of 2+4 is 36.
第一次调用宏时使用“y”代替#x；第二次调用把2+4转成字符串“2+4”。
2.##
　　##运算符可以用于类函数宏的替换部分。另外，##还可以用于类对象宏的替换部分。这个运算符把两个语言符号组合成单个语言符号。简单理解就是a##b转化为ab,把a和b连在一起了
例如：
#define XNAME(n) x##n
这样宏调用：
XNAME(4)
展开后：
x4
程序：

#include <stdio.h>
 #define XNAME(n) x##n
 #define PXN(n) printf("x"#n" = %d\n",x##n)
int main(void)
{
    int XNAME(1)=12;//int x1=12;
    PXN(1);//printf("x1 = %d\n", x1);
    return 0;
}

输出结果：
x1=12
3.可变参数宏 …和_ VA_ARGS _
　　VA_ARGS 是一个可变参数的宏，很少人知道这个宏，这个可变参数的宏是新的C99规范中新增的，目前似乎只有gcc支持（VC6.0的编译器不支持）。
　　实现思想就是宏定义中参数列表的最后一个参数为省略号（也就是三个点）。这样预定义宏_ VA_ARGS _就可以被用在替换部分中，替换省略号所代表的字符串。比如：

#define PR(...) printf(__VA_ARGS__)
int main()
{
    int wt=1,sp=2;
    PR("hello\n");
    PR("weight = %d, shipping = %d",wt,sp);
    return 0;
}

输出结果：
hello
weight = 1, shipping = 2
省略号只能代替最后面的宏参数。
#define W(x,…,y)错误！

freertos实例：

#define osThreadDef(name, thread, priority, instances, stacksz)  \
const osThreadDef_t os_thread_def_##name = \
{ #name, (thread), (priority), (instances), (stacksz)}

上诉宏定义中出现了##和# 符号，其中

##是一个连接符号，用于把参数连在一起；

#是“字符串化”的意思。出现在宏定义中的#是把跟在后面的参数转换成一个字符串。

例如：

#define paster( n ) printf( "token" #n" = %d\n ", token##n )

所以paster(9);就是相当于 printf("token 9 = %d\n",token9);

那么osThreadDef(Task_LED1, Func_LED1, osPriorityNormal, 0, 128);等价于下面的定义

#defineosThreadDef(Task_LED1, Func_LED1, osPriorityNormal, 0, 128) \
const osThreadDef_t os_thread_def_Task_LED1 = { Task_LED1,Func_LED1,osPriorityNormal, 0, 128}

linux驱动实例：

module_platform_driver(axi_i2s_driver);

#define module_platform_driver(__platform_driver) \
    module_driver(__platform_driver, platform_driver_register, \
            platform_driver_unregister)

#define module_driver(__driver, __register, __unregister, ...) \
static int __init __driver##_init(void) \
{ \
    return __register(&(__driver) , ##__VA_ARGS__); \
} \
module_init(__driver##_init); \
static void __exit __driver##_exit(void) \
{ \
    __unregister(&(__driver) , ##__VA_ARGS__); \
} \
module_exit(__driver##_exit);

那么对module_platform_driver(axi_i2s_driver);进行第一步展开，即：

module_driver(axi_i2s_driver, platform_driver_register,platform_driver_unregister)

继续展开下一层，…并没有实际参数，对应的需要删除##VA_ARGS即：

#define module_driver(axi_i2s_driver, platform_driver_register,platform_driver_unregister) \
static int __init axi_i2s_driver_init(void) \
{ \
    return platform_driver_register(&(axi_i2s_driver) ); \
} \
module_init(axi_i2s_driver_init); \
static void __exit axi_i2s_driver_exit(void) \
{ \
    platform_driver_unregister(&(axi_i2s_driver) ); \
} \
module_exit(axi_i2s_driver_exit);

　　module_platform_driver()宏的作用就是定义指定名称的平台设备驱动注册函数和平台设备驱动注销函数，并且在函数体内分别通过platform_driver_register()函数和platform_driver_unregister()函数注册和注销该平台设备驱动。

VA_LIST 是在C语言中解决变参问题的一组宏，变参问题是指参数的个数不定，可以是传入一个参数也可以是多个;可变参数中的每个参数的类型可以不同,也可以相同;可变参数的每个参数并没有实际的名称与之相对应，用起来是很灵活。

va_list 用法示例

#include <stdarg.h> 
 
int AveInt(int,...);
 
 void main()
{
   printf("%d/t",AveInt(2,2,3));
   printf("%d/t",AveInt(4,2,4,6,8));
 
   return;
}
 
int AveInt(int v,...)
{
   int ReturnValue=0;
   int i=v;
 
   va_list ap ;
   va_start(ap,v);
 
   while(i>0)
   {
       ReturnValue+=va_arg(ap,int) ;
       i--;
   ｝
   va_end(ap); 
   return ReturnValue/=v;
}

VA_LIST的用法：
（1）首先在函数里定义一具VA_LIST型的变量，这个变量是指向参数的指针；
（2）然后用VA_START宏初始化变量刚定义的VA_LIST变量；
（3）然后用VA_ARG返回可变的参数，VA_ARG的第二个参数是你要返回的参数的类型（如果函数有多个可变参数的，依次调用VA_ARG获取各个参数）；
（4）最后用VA_END宏结束可变参数的获取。

上面是va_list的具体用法，下面讲解一下va_list各个语句含义（如上示例黑体部分）和va_list的实现。

     可变参数是由宏实现的，但是由于硬件平台的不同，编译器的不同，宏的定义也不相同，下面是VC6.0中x86平台的定义 ：
 
      typedef char * va_list;     // TC中定义为void*
      #define _INTSIZEOF(n)    ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) ) //为了满足需要内存对齐的系统
      #define va_start(ap,v)    ( ap = (va_list)&v + _INTSIZEOF(v) )     //ap指向第一个变参的位置，即将第一个变参的地址赋予ap
      #define va_arg(ap,t)       ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )   /*获取变参的具体内容，t为变参的类型，如有多个参数，则通过移动ap的指针来获得变参的地址，从而获得内容*/
      #define va_end(ap) ( ap = (va_list)0 )   //清空va_list，即结束变参的获取

va_list ap ; 定义一个va_list变量ap
va_start(ap,v) ；执行ap = (va_list)&v + _INTSIZEOF(v)，ap指向参数v之后的那个参数的地址，即 ap指向第一个可变参数在堆栈的地址。
va_arg(ap,t) ， ( (t )((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )取出当前ap指针所指的值，并使ap指向下一个参数。 ap＋= sizeof(t类型)，让ap指向下一个参数的地址。然后返回ap-sizeof(t类型)的t类型指针，这正是第一个可变参数在堆栈里的地址。然后用取得这个地址的内容。
va_end(ap) ; 清空va_list ap。

使用VA_LIST应该注意的问题：
（1）因为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢,可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能地识别不同参数的个数和类型. 也就是说,你想实现智能识别可变参数的话是要通过在自己的程序里作判断来实现的.
（2）另外有一个问题,因为编译器对可变参数的函数的原型检查不够严格,对编程查错不利.不利于我们写出高质量的代码。
（3）由于参数的地址用于VA_START宏，所以参数不能声明为寄存器变量，或作为函数或数组类型。