linux头文件如何保存,头文件与源文件中都分别存放哪些东西

在C代码文件中，我们经常会看到两类文件：

一类是：".h"文件

一类是：".c"文件

".h"文件，就是我们常说的头文件。

".c"文件，就是我们常说的源代码文件。

而在做开发的时候，经常不知道要把哪些东西放到".h"文件之中，又要把哪些东西放到".c"文件中。

今天就详细介绍一下这两个文件(".h"和".c")中都应该存放写什么东西。

首先，先介绍".h"文件。

".h"文件中存放的东西有：

1.include所需要的头文件。 如 #include

2.宏定义。          如： #define SIZE 10;

3.类型的定义。      如： typedef struct student{} student

4.外部变量的声明。  如： extern struct task_struct *task;

extern spinlock_t spinlock;

5.函数的声明。      如： int sum(int a, int b

6.static inline函数。如：static inline sum(int a, int b);

以下是一个linux源码包中的头文件：2 //头文件说明，用于防止头文件重名

3 #ifndef _LINUX_PID_H

4 #define _LINUX_PID_H

5

6 #include 

7

8 //类型定义

9 enum pid_type

10 {

11     PIDTYPE_PID,

12     PIDTYPE_PGID,

13     PIDTYPE_SID,

14     PIDTYPE_MAX

15 };

16

17 struct upid {

18     /* Try to keep pid_chain in the same cacheline as nr for find_vpid */

19     int nr;

20     struct pid_namespace *ns;

21     struct hlist_node pid_chain;

22 };

23

24 struct pid

25 {

26     atomic_t count;

27     unsigned int level;

28     /* lists of tasks that use this pid */

29     struct hlist_head tasks[PIDTYPE_MAX];

30     struct rcu_head rcu;

31     struct upid numbers[1];

32 };

47 //外部变量的声明

48 extern struct pid init_struct_pid;

49 extern struct pid_namespace init_pid_ns;

50

51 //外部函数声明

52 extern void put_pid(struct pid *pid);

53 extern struct task_struct *pid_task(struct pid *pid, enum pid_type);

54 extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);

55 extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);

56 extern void attach_pid(struct task_struct *task, enum pid_type type,

57             struct pid *pid);

58 extern void detach_pid(struct task_struct *task, enum pid_type);

59 extern void change_pid(struct task_struct *task, enum pid_type,

60             struct pid *pid);

61 extern void transfer_pid(struct task_struct *old, struct task_struct *new,

62              enum pid_type);

64 // static inline 函数

65 static inline struct pid_namespace *ns_of_pid(struct pid *pid)

66 {

67     struct pid_namespace *ns = NULL;

68     if (pid)

69         ns = pid->numbers[pid->level].ns;

70     return ns;

71 }

72

73 static inline pid_t pid_nr(struct pid *pid)

74 {

75     pid_t nr = 0;

76     if (pid)

77         nr = pid->numbers[0].nr;

78     return nr;

79 }

81

82 //宏定义

83 #define do_each_pid_task(pid, type, task)               \

84     do {                                \

85         struct hlist_node *pos___;              \

86         if ((pid) != NULL)                  \

87             hlist_for_each_entry_rcu((task), pos___,    \

88                 &(pid)->tasks[type], pids[type].node) {

89

90 #define while_each_pid_task(pid, type, task)                \

91                 if (type == PIDTYPE_PID)        \

92                     break;              \

93             }                       \

94     } while (0)

95

96 #define do_each_pid_thread(pid, type, task)             \

97     do_each_pid_task(pid, type, task) {             \

98         struct task_struct *tg___ = task;           \

99         do {

100

101 #define while_each_pid_thread(pid, type, task)              \

102         } while_each_thread(tg___, task);           \

103         task = tg___;                       \

104     } while_each_pid_task(pid, type, task)

105 #endif /* _LINUX_PID_H */

".c"文件中存放的东西有：

1.需要的头文件。

2.全局变量。即头文件中的"extern int 变量名"声明的变量在这儿要进行定义与初始化；

3.只在本文件中使用的变量。即 static 变量类型

4.全局函数的实现。即头文件中的"extern int 函数名"声明的函数要在这儿进行实现。

5.局部函数的实现。即static 变量类型 函数名

linux源码中的".c"文件：29 //包含的头文件

30 #include 

31 #include 

32 #include 

33 #include 

34 #include 

35 #include 

36 #include 

37 #include 

38 #include 

39 #include 

40

41 //只在本文件中使用的宏定义

42 #define pid_hashfn(nr, ns)  \

43     hash_long((unsigned long)nr + (unsigned long)ns, pidhash_shift)

//定义只在本文件中使用的变量；

46 static struct hlist_head *pid_hash;

47 static unsigned int pidhash_shift = 4;

48

49 //全局变量的声明以及初始化，其他文件也可以使用，通过#include即可

50 struct pid init_struct_pid = INIT_STRUCT_PID;

51

52 int pid_max = PID_MAX_DEFAULT;

53 int pid_max_min = RESERVED_PIDS + 1;

54 int pid_max_max = PID_MAX_LIMIT;

55 struct pid_namespace init_pid_ns = {

56     .kref = {

57         .refcount       = ATOMIC_INIT(2),

58     },

59     .pidmap = {

60         [ 0 ... PIDMAP_ENTRIES-1] = { ATOMIC_INIT(BITS_PER_PAGE), NULL }

61     },

62     .last_pid = 0,

63     .level = 0,

64     .child_reaper = &init_task,

65 };

66 EXPORT_SYMBOL_GPL(init_pid_ns);

68 //函数的实现,其他文件通过#include就可以使用此函数；

69 int is_container_init(struct task_struct *tsk)

70 {

71     int ret = 0;

72     struct pid *pid;

73

74     rcu_read_lock();

75     pid = task_pid(tsk);

76     if (pid != NULL && pid->numbers[pid->level].nr == 1)

77         ret = 1;

78     rcu_read_unlock();

79

80     return ret;

81 }

82 EXPORT_SYMBOL(is_container_init);

83

84 //只能被本文件中的其他函数使用的函数。

85 static void free_pidmap(struct upid *upid)

86 {

87     int nr = upid->nr;

88     struct pidmap *map = upid->ns->pidmap + nr / BITS_PER_PAGE;

89     int offset = nr & BITS_PER_PAGE_MASK;

90

91     clear_bit(offset, map->page);

92     atomic_inc(&map->nr_free);

93 }