我想把/linux/list.h头文件用在自己的程序当中,

[bw_0927]

写了个简单的程序如下

 #include <stdio.h>
      2 #include <stdlib.h>
      3 #include "list.h"
      4 struct stock
      5 {
      6         char name[20];
      7         int price;
      8 };
      9 struct my_list
     10 {
     11         struct stock gupiao;
     12         struct list_head list;
     13 };
     14
     15 int main()
     16 {return 0;}

为什么报错说stock.c:12: field `list' has incomplete type

这是什么原因啊,该怎么解决?

谢谢了!

[fensnote]

就是直接include啊

[niulin]

我以前试过，
直接#include <linux/list.h> 或者#include "linux/list.h"
或者include <list.h> 或者#include "list.h" 都不行。

试试下面的代码吧，也是从linux/list中节选过来的:

#ifndef LIST_H
#define LIST_H

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

static inline void INIT_LIST_HEAD(struct list_head *list)
{
	list->next = list;
	list->prev = list;
}

/*
 * 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 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;
}

/**
 * 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 inline void 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 inline void 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 inline void __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 inline void list_del(struct list_head *entry)
{
	__list_del(entry->prev, entry->next);
}

/**
 * list_replace - replace old entry by new one
 * @old : the element to be replaced
 * @new : the new element to insert
 *
 * If @old was empty, it will be overwritten.
 */
static inline void list_replace(struct list_head *old,
				struct list_head *new)
{
	new->next = old->next;
	new->next->prev = new;
	new->prev = old->prev;
	new->prev->next = new;
}

/**
 * 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 inline void 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 inline void list_move_tail(struct list_head *list,
				  struct list_head *head)
{
	__list_del(list->prev, list->next);
	list_add_tail(list, head);
}

/**
 * list_is_last - tests whether @list is the last entry in list @head
 * @list: the entry to test
 * @head: the head of the list
 */
static inline int list_is_last(const struct list_head *list,
				const struct list_head *head)
{
	return list->next == head;
}

/**
 * list_empty - tests whether a list is empty
 * @head: the list to test.
 */
static inline int list_empty(const struct list_head *head)
{
	return head->next == head;
}

/**
 * list_is_singular - tests whether a list has just one entry.
 * @head: the list to test.
 */
static inline int list_is_singular(const struct list_head *head)
{
	return !list_empty(head) && (head->next == head->prev);
}



/**
 * 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) \
	container_of(ptr, type, member)

/**
 * list_for_each	-	iterate over a list
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 *
 * This variant differs from list_for_each() in that it's the
 * simplest possible list iteration code, no prefetching is done.
 * Use this for code that knows the list to be very short (empty
 * or 1 entry) most of the time.
 */
#define list_for_each(pos, head) \
	for (pos = (head)->next; pos != (head); pos = pos->next)

#endif

[bw_0927]

为什么它自带的头文件不能用,

自带的头文件该怎么修改一下就可以用了?

[bbo123]

直接把里面的相关内容或者函数拷贝下来，自己定义一下。我有一个函数就是这么做的，

[帅得不敢出门]

list是在内核态中用的
你直接在用户态include自然不可用

可以试下：
加上
#define __KERNEL__
或者编译时加上 -D__KERNEL__ 或者 -D_LVM_H_INCLUDE

[bbo123]

把/linux/list.h头文件用在自己的程序当
感觉得这么写#include<linux/list.h>

lz试试

[LeadenSky2008]

ls别扯了,就一个.h文件,什么内核态不内核态的.我们都是直接用的.

[alickguo]

ls的2008同志，说你是棒槌，估计还高估你了.

[谭海燕]

有火药味。


各位息怒

[ouyangjinlin]

struct list_head list;
list_head没有声明

[ouyangjinlin]

你自己声明一个吧，链接表是很容易出问题，指针都够你吃的。

[einsteinz]

要想包含它，找到具体路径 比如：#include <libxml2/libxml/list.h>
但是编译时会报其错。

[FoxMessire]

[Quote=引用 1 楼 bbo123 的回复:]

把/linux/list.h头文件用在自己的程序当
感觉得这么写#include<linux/list.h>

lz试试
[/Quote]
up

[linyangwo2008]

看到一群没有自己用过的人，你用#include<linux/list.h>试试。。可以?

[yet123456]

find / -name list.h找到路径 之后 再include