通用链表实现（参考Linux List）

　　最近参考Linux实现的通用双向链表时，因typeof并不是标准c规定的关键字，除GCC编译器外其他编译器未必支持typeof关键字，所以在使用上并不能想Linux所实现的链表哪样灵活，它要求将连接器即链表结构作为用户自定义结构体的第一个元素使用，话不多说，直接上代码，内嵌详细注释。

IList.h

 #ifndef _I_LIST_H_2012_11_23_
 #define _I_LIST_H_2012_11_23_
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /** \brief 双向链表连接器
  *  \details 实现用户自定义结构链表的连接器的结构定义，使用注意事项：
     1. 务必将其嵌入到用户自定义结构体元素的顶端；
     2. 务必使用结构类型而非其指针类型嵌入到用户自定义结构体
  *  \typedef typedef struct _IList IList,*pIList
  */
 typedef struct _IList
 {
     struct _IList *_prev;
     struct _IList *_next;
 }IList, *pIList;
 
 /**
   \brief    遍历链表所有节点
   \details  遍历链表所有节点，在遍历过程中，请勿执行添加、删除操作
 
   \param[in]  pList 链表对象
   \param[out] pLink 节点
  */
 #define IList_Foreach(pList, pos) \
     for ( \
         pos = pos = (pList)->_next; \
         pos != (pList); \
         pos = pos->_next \
     )
 
 /**
   \brief    遍历链表所有节点
   \details  安全遍历链表所有节点，在遍历过程中，可以删除节点
 
   \param[in]  pList 链表对象
   \param[out] pLink 节点
  */
 #define IList_Foreach_Salf(pList, temp, pos) \
     for ( \
         pos = (pList)->_next, temp = pos->_next; \
         pos != (pList); \
         pos = temp, temp = pos->_next\
     )
 
 /**
   \brief    链表初始化
 
   \param[in]  pList 链表对象
  */
 void IList_Init(pIList pList);
 
 /**
   \brief    插入新节点
   \details  将新节点插入链表指定节点之前
 
   \param[in]  pList 链表对象
   \param[in]  pLink 指定节点
   \param[in]  pNewLink 带插入节点
  */
 void IList_Insert(pIList pLink, pIList pNewLink);
 
 /**
   \brief    插入新节点至链表尾部
 
   \param[in]  pList 链表对象
   \param[in]  pLink 指定节点
   \param[in]  pNewLink 带插入节点
  */
 void IList_Append(pIList pList, pIList pNewLink);
 
 /**
   \brief    插入新节点至链表尾头部
 
   \param[in]  pList 链表对象
   \param[in]  pLink 指定节点
   \param[in]  pNewLink 带插入节点
  */
 void IList_Prepend(pIList pList, pIList pNewLink);
 
 /**
   \brief    删除指定节点
 
   \param[in]  pList 链表对象
   \param[in]  pLink 带删除的节点
  */
 void IList_Remove(pIList pLink);
 
 /**
   \brief    获取表头节点
 
   \param[in]  pList 链表对象
 
   \return   NULL: 链表为空
             其他: 表头节点地址
  */
 pIList IList_Head(pIList pList);
 
 /**
   \brief    获取表尾节点
 
   \param[in]  pList 链表对象
 
   \return   NULL: 链表为空
             其他: 表尾节点地址
  */
 pIList IList_Tail(pIList pList);
 
 /**
   \brief    检测链表是否为空
 
   \param[in]  pList 链表对象
 
   \return   0: 链表非空
             1: 链表为空
  */
 int IList_IsEmpty(pIList pList);
 /**
   \brief    获取链表节点数
 
   \param[in]  pList 链表对象
 
   \return   链表节点数
  */
 int IList_Size(pIList pList);
 
 /**
   \brief    获取指定节点的后一节点
 
   \param[in]  pList 链表对象
   \param[in]  pLink 指定的节点
 
   \return   NULL: 指定节点为尾节点
             其他: 指定节点后一节点地址
  */
 pIList IList_Next(pIList pList, pIList pLink);
 
 /**
   \brief    获取指定节点的前一节点
 
   \param[in]  pList 链表对象
   \param[in]  pLink 指定的节点
 
   \return   NULL: 指定节点为头节点
             其他: 指定节点前一节点地址
  */
 pIList IList_Prev(pIList pList, pIList pLink);
 
 /**
   \brief    获取链表中第index个节点
 
   \param[in]  pList 链表对象
   \param[in]  index 节点序号,从1计数
 
   \return   NULL: 指定序号无节点
             其他: 链表中第index所对应的节点
  */
 pIList IList_Nth(pIList pList, int index);
 
 /**
   \brief    获取链表中指定节点的序号
 
   \param[in]  pList 链表对象
   \param[in]  pLink 指定节点
 
   \return   NULL: 指定序号无节点
             其他: 链表中第index所对应的节点
  */
 int IList_Find(pIList pList, pIList pLink);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif//_I_LIST_H_2012_11_23_

IList.c

 #include <stdio.h>
 #include "iList.h"
 
 void IList_Init(pIList pList)
 {
     pList->_prev = pList;
     pList->_next = pList;
 }
 
 void IList_Insert(pIList pLink, pIList pNewLink)
 {
     pNewLink->_prev = pLink->_prev;
     pNewLink->_next = pLink;
     pNewLink->_prev->_next = pNewLink;
     pNewLink->_next->_prev = pNewLink;
 }
 
 void IList_Append(pIList pList, pIList pNewLink)
 {
     IList_Insert(pList, pNewLink);
 }
 
 void IList_Prepend(pIList pList, pIList pNewLink)
 {
     IList_Insert(pList->_next, pNewLink);
 }
 
 void IList_Remove(pIList pLink)
 {
     pLink->_prev->_next = pLink->_next;
     pLink->_next->_prev = pLink->_prev;
 }
 
 pIList IList_Head(pIList pList)
 {
     return pList->_next != pList ? pList->_next : NULL;
 }
 
 pIList IList_Tail(pIList pList)
 {
     return pList->_prev != pList ? pList->_prev : NULL;
 }
 
 int IList_IsEmpty(pIList pList)
 {
     return pList->_next == pList;
 }
 
 int IList_Size(pIList pList)
 {
     int count = ;
     pIList temp = NULL;
 
     if (pList->_next == pList)
         return ;
 
     IList_Foreach(pList, temp)
     {
         count ++;
     }
 
     return count;
 }
 
 pIList IList_Next(pIList pList, pIList pLink)
 {
     return pLink->_next != pList ? pLink->_next : NULL;
 }
 
 pIList IList_Prev(pIList pList, pIList pLink)
 {
     return pLink->_prev != pList ? pLink->_prev : NULL;
 }
 
 pIList IList_Nth(pIList pList, int index)
 {
     pIList pLink = NULL;
     int count = ;
 
     IList_Foreach(pList, pLink)
     {
         count ++;
         if (count == index)
             return pLink;
     }
 
     return NULL;
 }
 
 int IList_Find(pIList pList, pIList pLink)
 {
     pIList pTemp = NULL;
     int index = ;
 
     pTemp = IList_Head(pList);
 
     while ((pTemp != NULL) && (pTemp != pLink))
     {
         index++;
         pTemp = IList_Next(pList, pTemp);
     }
 
     if (pTemp == NULL)
         return (-);
     else
         return (index);
 }

IListTest.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "iList.h"
 
typedef struct _Student
{
    IList _list;
 
    int _id;
    char *name;
}Student, *pStudent;
 
int main(int argc, char *argv[])
{
    int i = ;
    int num = ;
    int count = ;
    pStudent temp= NULL;
    pIList list, link;
 
    if (argc > )
        num = atoi(argv[]);
 
    list = (IList *)malloc(sizeof(IList));
    if (!list)
    {
        printf("Error in malloc.\n");
        return -;
    }
    memset(list, , sizeof(IList));
 
    IList_Init(list);
    for (i = ; i < num; i ++)
    {
        temp = malloc(sizeof(Student));
        if (!temp)
            return -;
        memset(temp, , sizeof(Student));
        temp->_id = i + ;
        IList_Append(list, &temp->_list);
        //IList_Prepend(list, &temp->_list);
    }
 
    IList_Foreach(list, link)
    {
        temp = (pStudent)link;
        printf("%d\t", temp->_id);
    }
    printf("\n");
 
    printf("Input the num(1 ~ %d) that you want to:\n", IList_Size(list));
    scanf("%d", &count);
    link = IList_Nth(list, count);
    printf("Num %d id: %d\n", count, ((pStudent)link)->_id);
    printf("Id %d num: %d\n", ((pStudent)link)->_id, IList_Find(list, link));
 
    printf("List count: %d\n", IList_Size(list));
    /*for (link = IList_Head(list);!IList_IsEmpty(list);)
    {
        pIList tLink = link;
        link = IList_Next(list, link);
        IList_Remove(tLink);
        free(tLink);
    }*/
    do
    {
        pIList n, pos;
        IList_Foreach_Salf(list, n, pos)
        {
            IList_Remove(pos);
            free(pos);
        }
    } while ();
    printf("List count: %d\n", IList_Size(list));
 
    free(list);
 
    return ;
}