linux list.h文件,linux list.h 实例

#ifndef __LIST_H

#define __LIST_H

#if defined(WIN32)

#define INLINE __inline

#else

#define INLINE inline

#endif

/* This file is from Linux Kernel (include/linux/list.h)

* and modified by simply removing hardware prefetching of list items.

* Here by copyright, credits attributed to where ever they belong.

* Get from http://isis.poly.edu/kulesh/stuff/src/klist/

*/

/*

* Simple doubly linked list implementation.

*

* Some of the internal functions ("__xxx") are useful when

* manipulating whole lists rather than single entries, as

* sometimes we already know the next/prev entries and we can

* generate better code by using them directly rather than

* using the generic single-entry routines.

*/

struct list_head{

struct list_head*next, *prev;

};

#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \

struct list_head name = LIST_HEAD_INIT(name)

#define INIT_LIST_HEAD(ptr) do { \

(ptr)->next = (ptr); (ptr)->prev = (ptr); \

} while (0)

/*

* Insert a new entry between two known consecutive entries.

*

* This is only for internal list manipulation where we know

* the prev/next entries already!

*/

static INLINEvoid __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;

}

/**

* list_add - add a new entry

* @new: new entry to be added

* @head: list head to add it after

*

* Insert a new entry after the specified head.

* This is good for implementing stacks.

*/

static INLINEvoid list_add(struct list_head*new,struct list_head*head)

{

__list_add(new, head, head->next);

}

/**

* list_add_tail - add a new entry

* @new: new entry to be added

* @head: list head to add it before

*

* Insert a new entry before the specified head.

* This is useful for implementing queues.

*/

static INLINEvoid list_add_tail(struct list_head*new,struct list_head*head)

{

__list_add(new, head->prev, head);

}

/*

* Delete a list entry by making the prev/next entries

* point to each other.

*

* This is only for internal list manipulation where we know

* the prev/next entries already!

*/

static INLINEvoid __list_del(struct list_head*prev,struct list_head*next)

{

next->prev= prev;

prev->next= next;

}

/**

* list_del - deletes entry from list.

* @entry: the element to delete from the list.

* Note: list_empty on entry does not return true after this, the entry is in an undefined state.

*/

static INLINEvoid list_del(struct list_head*entry)

{

__list_del(entry->prev, entry->next);

entry->next= (void*)0;

entry->prev= (void*)0;

}

/**

* list_del_init - deletes entry from list and reinitialize it.

* @entry: the element to delete from the list.

*/

static INLINEvoid list_del_init(struct list_head*entry)

{

__list_del(entry->prev, entry->next);

INIT_LIST_HEAD(entry);

}

/**

* list_move - delete from one list and add as another's head

* @list: the entry to move

* @head: the head that will precede our entry

*/

static INLINEvoid list_move(struct list_head*list,struct list_head*head)

{

__list_del(list->prev, list->next);

list_add(list, head);

}

/**

* list_move_tail - delete from one list and add as another's tail

* @list: the entry to move

* @head: the head that will follow our entry

*/

static INLINEvoid list_move_tail(struct list_head*list,

struct list_head*head)

{

__list_del(list->prev, list->next);

list_add_tail(list, head);

}

/**

* list_empty - tests whether a list is empty

* @head: the list to test.

*/

static INLINEint list_empty(struct list_head*head)

{

return head->next== head;

}

static INLINEvoid __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;

}

/**

* list_splice - join two lists

* @list: the new list to add.

* @head: the place to add it in the first list.

*/

static INLINEvoid list_splice(struct list_head*list,struct list_head*head)

{

if(!list_empty(list))

__list_splice(list, head);

}

/**

* list_splice_init - join two lists and reinitialise the emptied list.

* @list: the new list to add.

* @head: the place to add it in the first list.

*

* The list at @list is reinitialised

*/

static INLINEvoid list_splice_init(struct list_head*list,

struct list_head*head)

{

if(!list_empty(list)) {

__list_splice(list, head);

INIT_LIST_HEAD(list);

}

}

/**

* list_entry - get the struct for this entry

* @ptr: the &struct list_head pointer.

* @type: the type of the struct this is embedded in.

* @member: the name of the list_struct within the struct.

*/

#define list_entry(ptr, type, member) \

((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

/**

* list_for_each - iterate over a list

* @pos: the &struct list_head to use as a loop counter.

* @head: the head for your list.

*/

#define list_for_each(pos, head) \

for (pos = (head)->next; pos != (head); \

pos = pos->next)

/**

* list_for_each_prev - iterate over a list backwards

* @pos: the &struct list_head to use as a loop counter.

* @head: the head for your list.

*/

#define list_for_each_prev(pos, head) \

for (pos = (head)->prev; pos != (head); \

pos = pos->prev)

/**

* list_for_each_safe - iterate over a list safe against removal of list entry

* @pos: the &struct list_head to use as a loop counter.

* @n: another &struct list_head to use as temporary storage

* @head: the head for your list.

*/

#define list_for_each_safe(pos, n, head) \

for (pos = (head)->next, n = pos->next; pos != (head); \

pos = n, n = pos->next)

/**

* list_for_each_entry - iterate over list of given type

* @pos: the type * to use as a loop counter.

* @head: the head for your list.

* @member: the name of the list_struct within the struct.

*/

#define list_for_each_entry(pos, head, member) \

for (pos = list_entry((head)->next, typeof(*pos), member); \

&pos->member != (head); \

pos = list_entry(pos->member.next, typeof(*pos), member))

/**

* list_for_each_entry_safe - iterate over list of given type safe against removal of list entry

* @pos: the type * to use as a loop counter.

* @n: another type * to use as temporary storage

* @head: the head for your list.

* @member: the name of the list_struct within the struct.

*/

#define list_for_each_entry_safe(pos, n, head, member) \

for (pos = list_entry((head)->next, typeof(*pos), member), \

n = list_entry(pos->member.next, typeof(*pos), member); \

&pos->member != (head); \

pos = n, n = list_entry(n->member.next, typeof(*n), member))

#endif

#include

#include

#include "list.h"

struct kool_list{

int to;

struct list_head list;

int from;

};

int main(int argc,char**argv)

{

struct kool_list *tmp;

struct list_head *pos, *q;

unsigned int i;

struct kool_list mylist;

INIT_LIST_HEAD(&mylist.list);

for(i=15; i!=0; --i)

{

tmp= (struct kool_list*)malloc(sizeof(struct kool_list));

printf("enter to and from:");

scanf("%d %d", &tmp->to, &tmp->from);

list_add(&(tmp->list), &(mylist.list));

}

printf("\n");

printf("traversing the list using list_for_each()\n");

list_for_each(pos, &mylist.list){

tmp= list_entry(pos,struct kool_list, list);

printf("to= %d from= %d\n", tmp->to, tmp->from);

}

printf("\n");

printf("traversing the list using list_for_each_entry()\n");

list_for_each_entry(tmp, &mylist.list, list) printf("to= %d from= %d\n", tmp->to, tmp->from);

printf("\n");

printf("deleting the list using list_for_each_safe()\n");

list_for_each_safe(pos, q, &mylist.list)

{

tmp= list_entry(pos,struct kool_list, list);

printf("freeing item to= %d from= %d\n", tmp->to, tmp->from);

list_del(pos);

free(tmp);

}

return0;

}

http://hi.baidu.com/chenxiawei2008/blog/item/5a7938c48c09a8c739db499c.html