![cover](https://img-home.csdnimg.cn/images/20230309035550.png)
嵌入式C常用的几个宏定义
链表宏在linux内核、鸿蒙内核、rtos和一些开源代码中用的非常多。链表宏是双向链表的经典实现方式,总代码不超过50行,相当精炼。宏的定义如下,其作用是将所传入指针N的两个指针域和都指向N。目的是完成单个节点的初始化工作,如下图示意了该过程。宏的定义如下,直接将宏展开,其意图很明显是定义一个新链表(H表示为传入宏的参数名),并且将H的两个指针域,都初始化为H地址本身,如下图示意了该过程。宏的定义
链表宏
链表宏在linux内核、鸿蒙内核、rtos和一些开源代码中用的非常多。链表宏是双向链表的经典实现方式,总代码不超过50行,相当精炼。
llist.h
#ifndef LLIST_HEADER_INCLUDED
#define LLIST_HEADER_INCLUDED
/*
* Linked list macros.
*/
struct llhead {
struct llhead *prev;
struct llhead *next;
};
#define LL_INIT(N) ((N)->next = (N)->prev = (N))
#define LL_HEAD(H) struct llhead H = { &H, &H }
/* 通过传入链表节点P,还原出节点所在结构体的指针,进而能对结构体进行相应操作。*/
#define LL_ENTRY(P,T,N) ((T *)((char *)(P) - offsetof(T, N)))
#define LL_ADD(H, N) \
do { \
((H)->next)->prev = (N); \
(N)->next = ((H)->next); \
(N)->prev = (H); \
(H)->next = (N); \
} while (0)
#define LL_TAIL(H, N) \
do { \
((H)->prev)->next = (N); \
(N)->prev = ((H)->prev); \
(N)->next = (H); \
(H)->prev = (N); \
} while (0)
#define LL_DEL(N) \
do { \
((N)->next)->prev = ((N)->prev); \
((N)->prev)->next = ((N)->next); \
LL_INIT(N); \
} while (0)
#define LL_EMPTY(N) ((N)->next == (N))
#define LL_FOREACH(H,N) for (N = (H)->next; N != (H); N = (N)->next)
#define LL_FOREACH_SAFE(H,N,T) \
for (N = (H)->next, T = (N)->next; N != (H); \
N = (T), T = (N)->next)
#endif /* LLIST_HEADER_INCLUDED */
-
LL_INIT(N)
宏LL_INIT
的定义如下,其作用是将所传入指针N的两个指针域(N)->next
和(N)->prev
都指向N。目的是完成单个节点的初始化工作,如下图示意了该过程。
-
LL_HEAD(H)
宏LL_HEAD
的定义如下,直接将宏LL_HEAD
展开,其意图很明显是定义一个新链表H
(H表示为传入宏的参数名),并且将H的两个指针域,都初始化为H地址本身,如下图示意了该过程。
-
LL_ENTRY(P, T, N)
宏LL_ENTRY
的定义如下,其依赖于宏offsetof
。宏offsetof
功能描述为:C语言的offsetof()宏,是定义在stddef.h。用于求出一个struct或union数据类型的给定成员的size_t类型的字节偏移值(相对于struct或union数据类型的开头)。offsetof()宏有两个参数,分别是结构名与结构内的成员名。——维基百科
#define LL_ENTRY(P,T,N) ((T *)((char *)(P) - offsetof(T, N))) #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) // 宏LL_ENTRY的作用和linux中的宏container_of作用基本一样 #define container_of(ptr, type, member) ({ \ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ (type *)( (char *)__mptr - offsetof(type,member) );})
为了更好的理解宏
offsetof
,下面按照宏的定义来进行拆解说明。((TYPE *)0)
:取整数零并将其强转换为指向TYPE的指针。((TYPE *)0)->MEMBER)
:引用指向结构成员MEMBER。&((TYPE *)0)->MEMBER)
:取出MEMBER的地址。((size_t) &((TYPE *)0)->MEMBER)
:将结果转换为适当的数据类型。
由于该结构体是以0地址开头,所以最后该宏返回的结果就是该成员相对于结构体开头的偏移量。有了对宏
offsetof
的理解,再来看宏LL_ENTRY
就比较好理解了。宏LL_ENTRY
的功能是,根据结构体变量(T)中的域成员变量(N)的指针§来获取指向整个结构体变量的指针,下面来做拆解说明:offsetof(T, N)
:计算成员N相对于其结构体T开头的偏移量。((char *)(P)
:将指针P强转为字符指针类型,保证其做+/-运算时是以字节为单位。(char *)(P) - offsetof(T, N))
:P为成员N的指针,减去偏移量,指针到了结构体开头位置。((T *)((char *)(P)- offsetof(T, N)))
:将指针强转,得到了整个结构体指针。
-
LL_ADD(H, N)
宏LL_ADD
的定义如下,其作用是向双向链表H的头部添加节点N。根据LL_ADD
定义的语句顺序,对照着图片分析,会更加清晰。如下图,上面这张图片展示了添加节点N之前的结构,下图展示了添加节点N之后的结构。
-
LL_TAIL(H, N)
宏LL_TAIL
的定义如下,其作用是将节点N添加到双向链表H的尾部。宏LL_TAIL
的定义如下,其作用是向双向链表H的头部添加节点N。根据LL_TAIL
定义的语句顺序,对照着图片分析,会更加清晰。如下图,上面这张图片展示了添加节点N之前的结构,下图展示了添加节点N之后的结构,可以和LL_ADD
的结果进行对照。
-
LL_DEL(N)
宏LL_DEL
的定义如下,其作用是将节点N从双向链表中删除,并且节点N回到初始状态(其指针仅指向自身,不再指向其它地方)。 -
LL_EMPTY(N)
宏LL_EMPTY
的定义如下,其作用是判断链表N是否为空链表,返回布尔值false/true。如果节点的直接后继next指向其自身,就认为其为空节点。 -
LL_FOREACH(H,N)
宏LL_FOREACH
的定义如下,其作用是在双向链表H中,循环遍历出节点。 -
LL_FOREACH_SAFE(H,N,T)
宏LL_FOREACH_SAFE
的定义如下,其作用是在双向链表H中,循环遍历出节点N,因为其有提前存储N的下一个节点T。即使N节点被清理掉,也不影响其下一个节点的遍历,所以该宏一般用来做循环清除双向链表中节点的操作,而宏LL_FOREACH
仅用来遍历双向链表。#define LL_FOREACH_SAFE(H,N,T) \ for (N = (H)->next, T = (N)->next; N != (H); \ N = (T), T = (N)->next)
使用案例
在使用过程中并不需要数据域,而是通过指针将结构体串联成双向链表,并且通过该指针借助 LL_ENTRY
宏 能还原出该结构体指针,从而达到操作具体结构体的目的。
如下例子虽然不是完整能跑的程序,但是足够说明双向链表宏的关键用法。程序源码如下,现对照代码,描述双向链表宏的大致使用步骤:
- 定义一个结构体,结构体中必须包含
struct llhead link;
双向链表节点,这是后续能通过遍历双向链表节点,还原出该结构体指针的关键; - 通过
LL_HEAD(listeners);
,创建一个双向链表的头为listeners
; - 在具体逻辑中,肯定有地方通过
LL_TAIL(&listeners, &l->link);
或者LL_ADD(H, N)
,向双向链表的头listeners
添加节点; - 在需要操作1.所定义的结构体时,通过
LL_FOREACH(&listeners, lp)
遍历出节点指针; - 这是最精华的一步,通过4.遍历出来的节点,传入宏
LL_ENTRY(lp, struct listener, link);
中,还原出节点所在的结构体指针,根据逻辑的需要对结构体进行具体相应的操作; - 通过宏
LL_FOREACH_SAFE
来遍历双向链表,LL_DEL
来删除遍历出来的节点,达到清空链表的作用。
struct llhead {
struct llhead *prev;
struct llhead *next;
};
struct listener {
struct llhead link;
struct shttpd_ctx *ctx; /* Context that socket belongs */
int sock; /* Listening socket */
int is_ssl; /* Should be SSL-ed */
};
static LL_HEAD(listeners); /* List of listening sockets */
struct listener *l;
LL_TAIL(&listeners, &l->link);
struct llhead *lp;
LL_FOREACH(&listeners, lp) {
l = LL_ENTRY(lp, struct listener, link);
FD_SET(l->sock, &read_set);
if (l->sock > max_fd)
max_fd = l->sock;
DBG(("FD_SET(%d) (listening)", l->sock));
}
struct llhead *lp, *tmp;
LL_FOREACH_SAFE(&listeners, lp, tmp) {
l = LL_ENTRY(lp, struct listener, link);
(void) closesocket(l->sock);
LL_DEL(&l->link);
free(l);
}
其他
防止一个头文件被重复包含
#ifndef COMDEF_H
#define COMDEF_H
//头文件内容
#endif
类型重定义
typedef unsigned char boolean; /* Boolean value type. */
typedef unsigned long int uint32; /* Unsigned 32 bit value */
typedef unsigned short uint16; /* Unsigned 16 bit value */
typedef unsigned char uint8; /* Unsigned 8 bit value */
typedef signed long int int32; /* Signed 32 bit value */
typedef signed short int16; /* Signed 16 bit value */
typedef signed char int8; /* Signed 8 bit value */
获取指定地址上的一个字节或字
#define MEM_B( x ) ( *( (byte *) (x) ) )
#define MEM_W( x ) ( *( (word *) (x) ) )
最大值和最小值
#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )
#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )
得到一个field在结构体(struct)中的偏移量
#define FPOS( type, field ) \
/*lint -e545 */ ( (dword) &(( type *) 0)-> field ) /*lint +e545 */
得到一个结构体中field所占用的字节数
#define FSIZ( type, field ) sizeof( ((type *) 0)->field )
按照LSB格式把两个字节转化为一个Word
#define FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )
按照LSB格式把一个Word转化为两个字节
#define FLOPW( ray, val ) \
(ray)[0] = ((val) / 256); \
(ray)[1] = ((val) & 0xFF)
得到一个变量的地址(word宽度)
#define B_PTR( var ) ( (byte *) (void *) &(var) )
#define W_PTR( var ) ( (word *) (void *) &(var) )
得到一个字的高位和低位字节
#define WORD_LO(xxx) ((byte) ((word)(xxx) & 255))
#define WORD_HI(xxx) ((byte) ((word)(xxx) >> 8))
返回一个比X大的最接近的8的倍数
#define RND8( x ) ((((x) + 7) / 8 ) * 8 )
将一个字母转换为大写
#define UPCASE( c ) ( ((c) >= 'a' && (c) <= 'z') ? ((c) - 0x20) : (c) )
判断字符是不是10进制的数字
#define DECCHK( c ) ((c) >= '0' && (c) <= '9')
判断字符是不是16进制的数字
#define HEXCHK( c ) ( ((c) >= '0' && (c) <= '9') ||\
((c) >= 'A' && (c) <= 'F') ||\
((c) >= 'a' && (c) <= 'f') )
防止溢出的一个方法
#define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))
返回数组元素的个数
#define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )
返回无符号数n尾的值MOD_BY_POWER_OF_TWO(X,n)=X%(2^n)
#define MOD_BY_POWER_OF_TWO( val, mod_by ) \
( (dword)(val) & (dword)((mod_by)-1) )
对于IO空间映射在存储空间的结构,输入输出处理
#define inp(port) (*((volatile byte *) (port)))
#define inpw(port) (*((volatile word *) (port)))
#define inpdw(port) (*((volatile dword *)(port)))
#define outp(port, val) (*((volatile byte *) (port)) = ((byte) (val)))
#define outpw(port, val) (*((volatile word *) (port)) = ((word) (val)))
#define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val)))
跟踪调试
// ANSI标准说明了五个预定义的宏名:
__LINE__
__FILE__
__DATE__
__TIME__
__STDC__
参考:
![Logo](https://devpress.csdnimg.cn/79de2bf0b7994defa4242ef90d5513fa.jpg)
开放原子开发者工作坊旨在鼓励更多人参与开源活动,与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动,如meetup、训练营等,主打技术交流,干货满满,真诚地邀请各位开发者共同参与!
更多推荐
所有评论(0)