侵入式单链表的简单实现

众所周知，一个普通的单链表看起来是这样子滴，

typedef struct foo_s {
        int             data;
        struct foo_s    *next;
} foo_t;

结构体里包含了一个指向同类型的链表指针next; 而侵入式单链表则不同，让结构体包含一个成员变量，该成员变量是一个通用的链表结点。看起来是这个样儿滴，

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

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

所有包含了list_t link的结点构成一个单链表。如果说传统的单链表看起来是这样的，(背景为绿色：数据域，背景为白色：链接域；背景为灰色：结点的内存首地址)

那么，侵入式单链表看起来则是这样的，

于是，普通的单链表和侵入式单链表的区别在于：

• 普通的单链表的结点链接域存的是下一个结点的内存首地址
• 侵入式单链表的结点链接域存的是下一个结点的链接域成员变量的内存首地址

前一节我们详细分析了offsetof, typeof和container_of, 下面给出一个最简单的侵入式单链表实现。

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)))

/**
 * container_of - cast a member of a structure out to the containing structure
 * @ptr:        the pointer to the member.
 * @type:       the type of the container struct this is embedded in.
 * @member:     the name of the member within the struct.
 *
 */
#define container_of(ptr, type, member) ({                      
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    
        (type *)( (char *)__mptr - offsetof(type, member) );})

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

typedef void (*list_handler_t)(void *arg);

extern void list_init(list_t **head, list_t *node);
extern void list_fini(list_t *head, list_handler_t fini);
extern void list_show(list_t *head, list_handler_t show);

#ifdef  __cplusplus
}
#endif

#endif /* _LIST_H */

2. list.c

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

void
list_init(list_t **head, list_t *node)
{
        static list_t *tail = NULL;

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

        tail->next = node;
        tail = node;
        node->next = NULL;
}

void
list_show(list_t *head, list_handler_t show)
{
        for (list_t *p = head; p != NULL; p = p->next)
                show(p);
}

void
list_fini(list_t *head, list_handler_t fini)
{
        list_t *p = head;
        while (p != NULL) {
                list_t *q = p;
                p = p->next;
                fini(q);
        }
}

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_show(void *arg)
{
        list_t *q = (list_t *)arg;
        foo_t  *p = container_of(q, foo_t, link);

        printf("show (list) %p next (list) %p 	: "
            "show (node) %p = {0x%x, %p}
",
            q, p->link.next, p, p->data, p->link.next);
}

static void
foo_fini(void *arg)
{
        list_t *q = (list_t *)arg;
        foo_t  *p = container_of(q, foo_t, link);

        foo_t *next_nodep = NULL;
        if (p->link.next != NULL)
                next_nodep = container_of(p->link.next, foo_t, link);

        printf("free (node) %p next (node) %p
", p, next_nodep);
        p->link.next = NULL;
        free(p);
}

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

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

                printf("init (node) %p
", p);
                list_init(&head, &p->link);
        }

        list_show(head, foo_show);

        list_fini(head, foo_fini);

        return 0;
}

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 3
init (node) 0x88a1008
init (node) 0x88a1018
init (node) 0x88a1028
show (list) 0x88a100c next (list) 0x88a101c     : show (node) 0x88a1008 = {0x1001, 0x88a101c}
show (list) 0x88a101c next (list) 0x88a102c     : show (node) 0x88a1018 = {0x1002, 0x88a102c}
show (list) 0x88a102c next (list) (nil)         : show (node) 0x88a1028 = {0x1003, (nil)}
free (node) 0x88a1008 next (node) 0x88a1018
free (node) 0x88a1018 next (node) 0x88a1028
free (node) 0x88a1028 next (node) (nil)

小结： 在类型为foo_t的结构体中包含了成员变量list_t link, 那么根据link.next的值(本质上是内存地址)就能使用container_of()计算出结构体变量的内存首地址。一旦拿到了结构体变量的内存首地址，访问其内容就易如反掌。但是，本文中给出的实现是让list.c/list.h的消费者foo.c直接使用container_of(), 例如list_show()在访问具体的node里的data的时候是通过callback的方式，因此，list.c离真正的侵入式单链表实现还是有距离滴。欲知后事如何，且听下回分解。