链表的使用

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

#define uint unsigned int
#define uchar unsigned char
typedef long uint l_uint;
#define NAME_LENGTH (32)
typedef enum BOOL
{
 FALSE,
 TRUE,
}BOOL;
#define INVALID_INPUT (-2)
#define ZTE_OK (0)
#define ZTE_ERR (-1)
#define ZTE_DEF (1)
#define SEX_ENUM_NUM (3)
#define PUBLIC_ENUM_NUM (5)

#define point_param_check(input)\
do\
{\
 if(NULL == input)\
 return INVALID_INPUT;\
}while(0);

/* 定义双向链表结构体，其中包含一个指向前一个和后一个链表结点的指针 */
struct list_head
{
 struct list_head *next,*prev;
};

/* 定义链表初始化函数，将next prev指针均指向链表头结点 */
#define LIST_HEAD_INIT(ptr)\
do\
{\
 (ptr)->next = (ptr);\
 (ptr)->prev = (ptr);\
}while(0);

/* 定义遍历链表时使用的获取对象指针的函数 */
#define list_entry(ptr, type, member)\
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

/* 遍历链表中每一个结点的函数head 为链表头结点，
 * pos n 为struct list_head 类型的变量使用的时候需要在函数内定义 */
#define list_for_each_entry(pos, n, head)\
for(pos = (head)->next,n = pos->next;pos !=(head);\
 pos = n,n = pos->next)

/* 链表判空函数，非空返回TRUE  */
static inline BOOL list_isnot_empty(struct list_head *list)
{
 if(list->next==list)
 return TRUE;
 else
 return FALSE;
}

/* 将一个结点添加到链表的函数 */
static inline void _list_add(struct list_head *new,
        struct list_head *prev,
        struct list_head *next)
{
 next->prev = new;
 new->next = next;
 new->prev = prev;
 prev->next = new;
}

/* 删除一个链表结点的函数 */
static inline void _list_del(struct list_head *prev,
        struct list_head *next)
{
 prev->next = next;
 next->prev = prev;
}

/* 将一个结点添加到链表头结点之后的函数 */
static inline void list_head_later_add(struct list_head *head,
            struct list_head *new)
{
 _list_add(new,head,head->next);
}

/* 将一个结点添加到链表的头结点之前的函数 */
static inline void list_head_prev_add(struct list_head *head,
           struct list_head *new)
{
 _list_add(new,head->prev,head);
}

/* 删除链表中某一个结点的函数 */
static inline void list_del(struct list_head *entry)
{
 _list_del(entry->prev,entry->next);
 entry->prev = (void *)0;
 entry->next = (void *)0;
}

/* 移动某一个结点到链表头后面 */
static inline void list_move_head_later(struct list_head *list,
          struct list_head *head)
{
 _list_del(list->prev,list->next);
 list_head_later_add(head,list);
}

/* 移动某一个结点到链表头前面 */
static inline void list_move_head_prev(struct list_head *list,
            struct list_head *head)
{
 _list_del(list->prev,list->next);
 list_head_prev_add(head,list);
}

/* 链表拆分函数，将一个链表拆分成两个链表 */
static inline void _list_splice(struct list_head *list,
        struct list_head *head)
{
 struct list_head *first = list->next;
 struct list_head *last = list->prev;
 struct list_head *at = head->next;

 first->prev = head;
 head->next = first;
 last->next = at;
 at->prev = last;
}

/* 链表合并函数 */
static inline void list_splice(struct list_head *list,
          struct list_head *head)
{
 if(!list_isnot_empty(list))
 _list_splice(list,head);
}

/* 链表合并并初始化空链表的函数 */
static inline void list_splice_init(struct list_head *list,
         struct list_head *head)
{
 if(!list_isnot_empty(list))
 {
  _list_splice(list,head);
  LIST_HEAD_INIT(list);
 }
}

typedef enum SEX_E
{
 Man,
 Woman,
 Invalid_sex,

}SEX_E;

typedef enum PUBLIC_E
{
 Development,
 Testing,
 Human_resource,
 Accounting,
 Invalid_public,

}PUBLIC_E;
typedef struct SEX_INFO_T
{
 SEX_E sex;
 char despict[NAME_LENGTH];

}SEX_INFO_t;
typedef struct PUBLIC_INFO_T
{
 PUBLIC_E public;
 char despict[NAME_LENGTH];

}PUBLIC_INFO_t;
const SEX_INFO_t g_sex_info_table[SEX_ENUM_NUM]=
{
 {Man,"Man"},
 {Woman,"Woman"},
 {Invalid_sex,"Invalid_sex"}
};
const PUBLIC_INFO_t g_public_info_table[PUBLIC_ENUM_NUM]=
{
 {Development,"Development"},
 {Testing,"Testing"},
 {Human_resource,"Human_resource"},
 {Accounting,"Accounting"},
 {Invalid_public,"Invalid_public"}
};
typedef struct COMPANY_INFO_T
{
 char Name[NAME_LENGTH];
 SEX_E Sex;
 PUBLIC_E Public;
 l_uint Numbers;
}COMPANY_INFO_t;

typedef struct STORE_MEMBERS_INFO_T
{
 COMPANY_INFO_t Member_info;
 struct list_head list;

}STORE_MEMBERS_INFO_t;

#define MAXNUM (1024)
STORE_MEMBERS_INFO_t g_members_info_zte[MAXNUM];

struct list_head *list_head_get(int nums)
{
 struct list_head *head = NULL;
 if(nums<MAXNUM)
 {
  head = &g_members_info_zte[nums].list;
 }
 return head;
}
void init(void)
{
 uint num_loop = 0;

 memset(g_members_info_zte, 0, MAXNUM*sizeof(STORE_MEMBERS_INFO_t));
 for(num_loop=0;num_loop<MAXNUM;num_loop++)
 {
  LIST_HEAD_INIT(list_head_get(num_loop));
 }
 return;
}
int add_mem_info(uint num)
{
 int ret = ZTE_DEF;
 STORE_MEMBERS_INFO_t *mem_info = NULL;
 struct list_head *head = NULL;

 if(num>=MAXNUM)
 {
  printf("invalid parmers!\n");
  return INVALID_INPUT;
 }

 mem_info = (STORE_MEMBERS_INFO_t *)malloc(sizeof(STORE_MEMBERS_INFO_t));
 if(mem_info == NULL)
 {
  perror("malloc  fail\n");
  return ZTE_ERR;
 }
 memset(mem_info, 0,sizeof(STORE_MEMBERS_INFO_t));

 strcpy(mem_info->Member_info.Name,"liqiang");
 //memcpy(mem_info->Member_info.Name,"liqiang",strlen("liqiang"));
 mem_info->Member_info.Sex = Man;
 mem_info->Member_info.Public = Development;
 mem_info->Member_info.Numbers =10198838;

 head = list_head_get(num);
 point_param_check(head);
 if((NULL == mem_info->list.next)&&(NULL == mem_info->list.prev))
 {
  list_head_prev_add(head,&(mem_info->list));
  ret = ZTE_OK;
 }
 else
 {
  list_move_head_prev(&(mem_info->list),head);
  ret = ZTE_OK;
 }
 return ret;

}
int del_mem_info(uint num)
{
 int ret = ZTE_DEF;
 struct list_head *head = NULL;
 struct list_head *pos = NULL;
 struct list_head *npos = NULL;
 STORE_MEMBERS_INFO_t *mem_info = NULL;

 if(MAXNUM <= num)
 {
  printf("invalid params!\n");
  return INVALID_INPUT;
 }
 head = list_head_get(num);
 point_param_check(head);
 list_for_each_entry(pos,npos,head)
 {
  mem_info = list_entry(pos,STORE_MEMBERS_INFO_t,list);
  if(NULL != mem_info)
  {
   printf(" Member_info.Name:%s\n Member_info.Sex:%s\n Member_info.Public:%s\n Member_info.Numbers:%ld\n",
       mem_info->Member_info.Name,g_sex_info_table[mem_info->Member_info.Sex].despict,g_public_info_table[mem_info->Member_info.Public].despict,mem_info->Member_info.Numbers);
   list_del(&(mem_info->list));
   free(mem_info);
   ret = ZTE_OK;
  }
 }

 return ret;
}
int main(int argc, char *argv[])
{
 int ret = 0;
 pid_t p_pid = 0;
 pid_t c_pid = 0;
 pid_t pid = 0;

 init();
 pid = fork();
 if(pid<0)
 {
  perror("fork error!\n");
  exit(1);
 }
 else if(pid>0)
 {
  p_pid = getpid();
  printf("this is parent process![p_pid:%d]\n",p_pid);
//  sleep(5);
  #if 0
  ret = del_mem_info(0);
  if(ZTE_OK == ret)
  {
   printf("del mem_info success!\n");
  }
  else
  {
   printf("del mem_info fail [ret:%d]\n",ret);
   if(INVALID_INPUT == ret)
   {
    printf("input error!\n"); 
   }
   if(ZTE_ERR == ret)
   {
    printf("malloc error!\n");
   }
  }
  #endif
  waitpid(c_pid,NULL,0);
  exit(0);
 }
 else if(pid == 0)
 {
  c_pid = getpid();
  printf("this is child process![c_pid:%d]\n",c_pid);
  ret = add_mem_info(0);

  if(ZTE_OK == ret)
  {
   printf("add mem_info success!\n");
  }
  else
  {
   printf("add mem_info fail[ret:%d]\n",ret);
   if(INVALID_INPUT == ret)
   { 
    printf("del mem_info fail!\n");
   }
   if(ZTE_ERR == ret)
   { 
    printf("malloc error!\n");
   }
  }
  ret = del_mem_info(0);
  if(ZTE_OK == ret)
  {
   printf("del mem_info success!\n");
  }
  else
  {
   printf("del mem_info fail [ret:%d]\n",ret);
   if(INVALID_INPUT == ret)
   {
    printf("input error!\n"); 
   }
   if(ZTE_ERR == ret)
   {
    printf("malloc error!\n");
   }
  }
  exit(0);
 }

 return ZTE_OK;
}