侵入式单链表的简单实现(cont)

前一节介绍的侵入式链表实现在封装性方面做得不好，因为会让消费者foo.c直接使用宏container_of()。这一节对list的定义做了一点改进，如下所示：

typedef struct list_s {
        struct list_s *next;
        size_t offset;
} list_t;

既然链表结点已经保存了offset, 那么就不再需要宏container_of()了。(注：Solaris的侵入式双向循环链表就是这么玩的，跟Linux玩法不一样。)

1. list.h

 #ifndef _LIST_H
 #define _LIST_H

 #ifdef  __cplusplus
 extern "C" {
 #endif

 /**
  * offsetof - offset of a structure member
  * @TYPE:       the type of the struct.
  * @MEMBER:     the name of the member within the struct.
  */
 #define offsetof(TYPE, MEMBER) ((size_t)(&(((TYPE *)0)->MEMBER)))

 typedef struct list_s {
         struct list_s *next;
         size_t offset;
 } list_t;

 extern list_t *list_d2l(void *object, size_t offset);
 extern   void *list_l2d(list_t *list);

 #ifdef  __cplusplus
 }
 #endif

 #endif /* _LIST_H */

• list_d2l(): 根据数据(data)结点的内存首地址得到侵入式链表(list)结点的内存首地址。
• list_l2d(): 根据侵入式链表(list)结点的内存首地址得到数据(data)结点的内存首地址。

2. list.c

 /*
  * Generic single linked list implementation
  */
 #include <stdio.h>
 #include "list.h"

 list_t *
 list_d2l(void *object, size_t offset)
 {
         if (object == NULL)
                 return NULL;

         list_t *p = (list_t *)((char *)object + offset);
         p->offset = offset;
         p->next = NULL;

         return p;
 }

 void *
 list_l2d(list_t *list)
 {
         if (list == NULL)
                 return NULL;

         return (void *)((char *)list - list->offset);
 }

• list_d2l(): 侵入式链表结点的内存首地址 = 数据结点的内存首地址 + offset
• list_l2d(): 数据结点的内存首地址 = 侵入式链表结点的内存首地址 - offset

3. foo.c

 #include <stdio.h>
 #include <stdlib.h>
 #include "list.h"

 typedef struct foo_s {
         int     data;
         list_t  link;
 } foo_t;

 static void
 foo_init(list_t **head, void *object, size_t offset)
 {
         if (object == NULL)
                 return;

         printf("init (node) %p\n", object);
         list_t *node = list_d2l(object, offset);

         if (*head == NULL) {
                 *head = node;
                 return;
         }

         list_t *tail = NULL;
         for (list_t *p = *head; p != NULL; p = p->next)
                 tail = p;
         tail->next = node;
 }

 static void
 foo_fini(list_t *head)
 {
         list_t *p = head;
         while (p != NULL) {
                 list_t *q = p;
                 p = p->next;

                 void *obj = list_l2d(q);
                 printf("free (node) %p next (list) %p\n", obj, p);
                 free(obj);
         }
 }

 static void
 foo_show(list_t *head)
 {
         for (list_t *p = head; p != NULL; p = p->next) {
                 foo_t *obj = list_l2d(p);

                 printf("show (list) %p next (list) %p \t: "
                     "show (node) %p = {0x%x, {%p, %d}}\n",
                     &obj->link, obj->link.next,
                     obj, obj->data, obj->link.next, obj->link.offset);
         }
 }

 int
 main(int argc, char *argv[])
 {
         if (argc != ) {
                 fprintf(stderr, "Usage: %s <num>\n", argv[]);
                 return -;
         }

         list_t *head = NULL;
         for (int i = ; i < atoi(argv[]); i++) {
                 foo_t *p = (foo_t *)malloc(sizeof (foo_t));
                 if (p == NULL) /* error */
                         return -;
                 p->data = 0x1001 + i;

                 foo_init(&head, (void *)p, offsetof(foo_t, link));
         }

         foo_show(head);
         foo_fini(head);

         return ;
 }

注意： list_l2d()与container_of()是等效的。 例如：

                 foo_t *obj = list_l2d(p);

等效于

                   foo_t *obj = container_of(p, foo_t, link);

4. Makefile

 CC      = gcc
 CFLAGS  = -g -Wall -m32 -std=gnu99

 all: foo

 foo: foo.o list.o
         ${CC} ${CFLAGS} -o $@ $^

 foo.o: foo.c
         ${CC} ${CFLAGS} -c $<

 list.o: list.c list.h
         ${CC} ${CFLAGS} -c $<

 clean:
         rm -f *.o

 clobber: clean
         rm -f foo
 cl: clobber

5. 编译并运行

$ make
gcc -g -Wall -m32 -std=gnu99 -c foo.c
gcc -g -Wall -m32 -std=gnu99 -c list.c
gcc -g -Wall -m32 -std=gnu99 -o foo foo.o list.o

$ ./foo
init (node) 0x81a8008
init (node) 0x81a8018
init (node) 0x81a8028
show (list) 0x81a800c next (list) 0x81a801c     : show (node) 0x81a8008 = {0x1001, {0x81a801c, }}
show (list) 0x81a801c next (list) 0x81a802c     : show (node) 0x81a8018 = {0x1002, {0x81a802c, }}
show (list) 0x81a802c next (list) (nil)         : show (node) 0x81a8028 = {0x1003, {(nil), }}
free (node) 0x81a8008 next (list) 0x81a801c
free (node) 0x81a8018 next (list) 0x81a802c
free (node) 0x81a8028 next (list) (nil)

6. 用gdb查看链表

(gdb) b foo_show
Breakpoint  at 0x80485d4: file foo.c, line .
(gdb) r
Starting program: /tmp/list/foo
init (node) 0x804b008
init (node) 0x804b018
init (node) 0x804b028

Breakpoint , foo_show (head=0x804b00c) at foo.c:
      for (foo_t *p = list_head(head); p != NULL; p = list_next(&p->link)) {
(gdb) #
(gdb) x /2x head
0x804b00c:      0x0804b01c      0x00000004
(gdb) x /2x head->next
0x804b01c:      0x0804b02c      0x00000004
(gdb) x /2x head->next->next
0x804b02c:      0x00000000      0x00000004
(gdb) #
(gdb) p head
$ = (list_t *) 0x804b00c
(gdb) #
(gdb) x /3x 0x804b00c-0x4
0x804b008:      0x00001001      0x0804b01c      0x00000004
(gdb) x /3x 0x804b01c-0x4
0x804b018:      0x00001002      0x0804b02c      0x00000004
(gdb) x /3x 0x804b02c-0x4
0x804b028:      0x00001003      0x00000000      0x00000004
(gdb) #

小结：

在这一版本的侵入式链表实现中，实现细节已经被充分屏蔽，核心函数就两个，list_d2l()和list_l2d()，也很容易理解。当然，对于消费者程序来说，无需知晓数据（data）结点的内存首地址与链表(list)结点的内存首地址之间是如何相互转换的。

后记：

在上面的代码实现中，list_d2l()总是会将((list_t *)p)->next设置成NULL。这么做存在着一个问题，那就是一旦链表构造完成后，如果想从某一个数据结点通过list_d2l()找到对应的链表结点，就会将链表截断。于是，我对list_d2l()做了一点修改，并增加了三个基本的链表操作函数list_insert_tail(), list_insert_head()和list_delete()。

1. list_d2l()和list_l2d()

 /*
  * Cast ptr of DATA object node to ptr of LIST node
  */
 list_t *
 list_d2l(void *object, size_t offset)
 {
         if (object == NULL)
                 return NULL;

         return (list_t *)((char *)object + offset);
 }

 /*
  * Cast ptr of LIST node to ptr of DATA object node
  */
 void *
 list_l2d(list_t *list)
 {
         if (list == NULL)
                 return NULL;

         return (void *)((char *)list - list->offset);
 }

2. LIST_INIT_NODE()

 #define LIST_INIT_NODE(list, offset) do {       \
                 (list)->next = NULL;            \
                 (list)->offset = (offset);      \
         } while ()

3. 将数据结点插入到侵入式链表中

• list_insert_tail()    // 尾插法
• list_insert_head()  // 头插法

 /*
  * Insert an object after the tail of list
  */
 void
 list_insert_tail(list_t **head, void *object, size_t offset)
 {
         if (object == NULL)
                 return;

         list_t *node = list_d2l(object, offset);
         LIST_INIT_NODE(node, offset);

         if (*head == NULL) {
                 *head = node;
                 return;
         }

         list_t *tail = NULL;
         for (list_t *p = *head; p != NULL; p = p->next)
                 tail = p;
         tail->next = node;
 }

 /*
  * Insert an object before the head of list
  */
 void
 list_insert_head(list_t **head, void *object, size_t offset)
 {
         if (object == NULL)
                 return;

         list_t *node = list_d2l(object, offset);
         LIST_INIT_NODE(node, offset);

         if (*head == NULL) {
                 *head = node;
                 return;
         }

         node->next = *head;
         *head = node;
 }

4. 从侵入式连表中删除一个结点

 /*
  * Delete a node from list
  */
 void
 list_delete(list_t **head, list_t *node)
 {
         if (head == NULL || *head == NULL || node == NULL)
                 return;

         if (*head == node) {
                 *head = node->next;
                 return;
         }

         list_t *q = *head;
         for (list_t *p = *head; p != NULL; p = p->next) {
                 if (p == node)
                         break;
                 q = p;
         }
         q->next = node->next;
 }

如对完整的代码实现感兴趣，请戳这里。