1、为何引入链表
0 v& [3 {. y5 @& @在程序中经常面临一个问题，我们需要保存一定数量的对象，但是对象数目是不确定的，或者说是随时增加或减少的。这时候最简单的方法是创建一个足够大的数组，用来存储这些对象。我最近开发一个项目就遇到类似的问题，下面我把问题简化一下。

- o" e; U; M0 m# G; ^需求：通过PC下发一些矩形的坐标和宽高信息，每个区域有个ID编号，并在这些矩形内填充一定的数据。
; j/ H5 f5 X0 P1 ]2 R) ?
' [7 v5 X+ X' s( w7 Z4 V- P5 a通常情况下，最简单易懂的做法是，限制最多5个区域，每个区域存储1K数据。因此设置了这样的一个结构体（类似于面向对象语言里说的成员属性）。

! q) q  H. g1 W- X

1. typedef struct Area_Inf
   
2. {
   5 S! [1 A3 T% A2 V5 v" ?
3.   uint8_t ID;
   
4.   uint8_t X;
   , L4 g0 G9 n& r
5.   uint8_t Y;
     N9 T( w7 h+ a6 A2 x* X
6.   uint8_t Width;
   + A; J  m/ }, y0 r7 A
7.   uint8_t Height;
   + N& i  S1 ~% d0 G8 w" @
8.   uint8_t data_len;
   
9. }Area_Inf_Typedef;

复制代码

然后定义结构体的实体。
# M& z4 R- e2 N  o; }: N% {5 B

1. #define Area_Num 5
   & b5 a8 g0 K) z6 O9 Z* r; [- m
2. #define Area_cache 1024
   ) c' `6 x: Y3 k) h. J3 O
3. 
   
4. Area_Inf_Typedef Area_Info[Area_Num];
   
5. uint8_t Area_Data[Area_Num*Area_cache];//存储区域的数据
   
6. 
   % ]/ @# W5 ]7 L  L& ?
7. /*找到ID为5的区域，并将数据拷贝出去*/
   - R4 E/ c% X4 ^0 @
8. void main()
   
9. {
   
10.     uint8_t i;
    $ w8 ?  {. V3 t2 w* f; w6 X
11.     uint8_t data[1024];
    
12.     for(i = 0;i < Area_Num;i++)
    8 z2 }7 y0 [. [3 {; U
13.     {
    
14.         if(Area_Info<i>.</i>ID == 5)
    
15.         {
    
16. memcpy(data,&Area_Data[i*Area_cache ],Area_Info.data_len);
    ( s7 t6 i7 W9 N8 |. }4 _; ?7 R# r7 D. s
17.         }
      q7 |- ^% _" O  b
18.     }
    $ U1 S( x: w4 n
19. }

复制代码

上面这种做法是最简单易懂的，但不灵活，比如有客户要求10个区域，但是每个区域存储的数据很少，根本用不到1K。虽然上面的程序已经使用了宏定义，只需要修改宏定义就能实现要求。但这意味着不同的客户，需要编译不同的固件。

1. #define Area_Num 10
   
2. #define Area_cache 512

复制代码

; d8 X$ h2 N1 [: r6 D这样的程序存在的问题：

" |% Y! U6 O8 p- ?) e- h1、在内存资源很紧缺的单片机程序中，当区域数据很少时，这种程序的处理方法浪费了大量的内存空间。

; b4 X. t& ?0 Q1 I6 ?7 g2、数值固定，需要存储更多区域，即使还有内存，还是需要修改宏定义，重新编译固件，不灵活。

4 V+ n0 h+ e& ~这时需要引入链表来解决这个问题。

2、链表实现
/ A0 y. q  C7 ?# `) G链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的，且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作。链表的每个元素称为一个节点，每个节点都可以存储在内存中的不同的位置，为了表示每个元素与后继元素的逻辑关系，以便构成“一个节点链着一个节点”的链式存储结构，除了存储元素本身的信息外，还要存储其直接后继信息，因此，每个节点都包含两个部分，第一部分称为链表的数据区域，用于存储元素本身的数据信息。



5 s1 t# h+ \) E0 g& D# p7 l对于上面的问题，我们使用链表解决，需要配合内存管理才能实现。内存管理这一块，大家可以自己编写内存管理驱动，也可以使用C库的malloc和free函数。如何字节编写内存管理驱动不是本文的重点，下文将使用C库的malloc和free函数进行内存管理。
3 Q* a) D, m; V
1 B8 Z0 K3 L3 u; w$ o9 R$ _使用链表的方式，在原有的成员属性结构体的前提上，还要再封装多一层链表管理。以单向链表为例：

1. typedef struct Area_Inf
   - ~# @, G3 B1 Z# _
2. {
   2 r2 \6 Z9 h% v" c
3.   uint8_t ID;
   ' J& a$ ]4 h9 m- D, ]" s5 z: Y! [1 z
4.   uint8_t X;
   
5.   uint8_t Y;
   3 ]( L. z, B; B" z0 r  G
6.   uint8_t Width;
   
7.   uint8_t Height;
   
8.   uint8_t data_len;
   0 [: F6 V. }( q1 r
9.   uint8_t* Area_Data;
   
10. }Area_Inf_Typedef;
    
11. 
    
12. typedef struct Area_List_Inf
    
13. {
    ( _# s9 X0 [% f$ j* Z1 g0 C; O0 N
14.   Area_Inf_Typedef *Area_Inf;
    
15.   struct Area_List_Inf *next_Area_Inf;  //用于指向下一个
    
16. }Area_List_Inf_Typedef;
    
17. 
    
18. Area_List_Inf_Typedef *Head_Area_List; //链表的头指针

复制代码

" g! t7 H3 Y3 e( @$ n2 Y) h* G
由于在定义的时候，只定义了一个头指针，那么它也只是个指向了Area_List_Inf_Typedef也就是链表结构体的指针，同样没有内存空间，在没有创建新增链表之前，它是一个野指针。

所以，在具体应用之前，需要先执行一个初始化操作，也就是申请空间给链表管理结构体，然后头指针指向这个空间。
1 e( a9 C; ~' r( c1 h; y" m7 P9 p
0 r  r+ b. _. g9 y, s

1. /**
   
2. * @brief 动态区链表初始化
   2 j( X, f; v9 @( u. G- N
3. * @return int
   
4. */
   
5. int Area_List_Init(void)
   
6. {
   1 s$ b: ^9 O! t' b* N' g
7.   //申请链表类型大小的空间，并让头指针指向它
   
8.   Head_Area_List = (Area_List_Inf_Typedef*)malloc(sizeof(Area_List_Inf_Typedef));
   
9.   if(Head_Area_List == NULL)
   ; |5 f1 N/ ^6 I( c6 Z
10.     return false;
    
11. 
    ' s4 }! G( o& r" }6 `) M1 i
12.   //同时要标记下一个信息为空
    
13.   Head_Area_List->next_Area_Inf = NULL;
    4 t  r" b  w( O! ~. w2 O6 s& R8 S
14.   return true;
    & v# c# k+ R' s) ^1 N/ B% o
15. }

复制代码

% v/ S6 ]( m3 F- ?2 r: w通过PC下发一个新的区域信息后，增加新区域到链表末尾。

& ^  t+ b* \/ _( i, o

1. /**
   
2. * @brief 在链表末尾增加一个区域参数
   6 e7 X0 N% a9 B8 D1 T- x1 N$ J
3. * @param Area_Inf 增加的区域区参数指针
   
4. * @return int
   + S3 U. U9 y1 |
5. */
   2 f- P! V4 A2 k0 ~: F8 G! v
6. int Add_Area_ToList(Area_Inf_Typedef *Area_Inf)
   
7. {
   
8.   Area_List_Inf_Typedef *p = Head_Area_List;
   
9.   while(p->next_Area_Inf!=NULL)
   / g$ |3 p& i; T' T9 @
10.   {
    ; M4 Q  ]! a. C- A; ]; G+ J
11.     p = p->next_Area_Inf;
    : c% Y* P" F; R% G* [0 e1 {
12.   }
    
13. 
    4 \& ~- V7 F& u& d6 k
14.   //先申请链表结构体的空间，因为后续还要继续增加
    
15.   p->next_Area_Inf =  (Area_List_Inf_Typedef*)malloc(sizeof(Area_List_Inf_Typedef));
    
16.   if(p->next_Area_Inf == NULL)
    3 |# s. N5 {  W7 \9 ]# R
17.     return false;//申请不到内存，返回失败
    
18. 
    
19.   //指向刚刚申请的空间，并为需要存放的动态区信息申请对应的内存
    
20.   p = p->next_Area_Inf;
    ' E/ N2 {7 E0 ?0 R! @
21. 
    
22.   p->Area_Inf = (Area_Inf_Typedef*)malloc(sizeof(Area_Inf_Typedef));
    ( K0 a: _- D  }6 w3 C& ]
23.   if(p->Area_Inf == NULL)
    
24.   {
    : o0 a7 k% }) T! K
25.     free(p);//由于申请失败，先前申请的链表空间也要释放
    
26.     return false;
    * D& ], |9 ?9 C
27.   }   
    
28.   memcpy(p->Area_Inf,Area_Inf,sizeof(Area_Inf_Typedef));
    
29. 
    ' c' b" d, q; _1 V2 J; q% Y2 L4 }6 r
30.   /*拷贝数据*/
    
31.   p->Area_Inf->Area_Data = (uint8_t*)malloc(Area_Inf->data_len);
    + E, s! O- F  S# D+ p9 Y
32.   if(p->Area_Inf->Area_Data == NULL)
    
33.   {
    
34.     free(p->Area_Inf);
    2 b, j6 I2 o# D7 Z" _# {) N) V
35.     free(p);
    
36.     return false;
    
37.   }
    
38.   memcpy(p->Area_Inf->Area_Data,Area_Inf->Area_Data,Area_Inf->data_len);
    6 @; D5 e/ c( S  y/ d
39.   //标记这个链表的尾部
    ; c& m; U4 n0 f  a5 Q: M6 Y1 Y
40.   p->next_Area_Inf=NULL;
    
41.   //添加成功
    
42.   return true;
    ) ]2 `( b0 U: `
43. }

复制代码

# g3 K' o% X9 c! d
$ w. x- n  E5 v) h$ e% p1 l通过PC下发一个删除指定ID的区域命令。
% h1 z* Q. H$ A( ]

1. /**
     _  B0 W% x; `
2. * @brief 根据区域ID删除动态区
   : }" ~" x: a% u# k0 s2 F
3. * @param num 区域ID
   
4. * @return int
   
5. */
   / e) Z) p$ D1 u2 [7 _
6. int Delete_Area_Accordingn_ID(int num)
   
7. {
   ) K8 y7 Z/ h6 b1 J1 |- @, D# ]
8.   int res = false;
   
9.   Area_List_Inf_Typedef *p = Head_Area_List;
   
10. 
    
11.   while(p->next_Area_Inf!=NULL)
    5 [$ S  t5 t, @; {7 F! [/ o
12.   {
    
13.     Area_List_Inf_Typedef *temp = p;
    7 c& \8 |! D( Z
14.     p = p->next_Area_Inf;
    
15.     if(p->Area_Inf->ID == num)//匹配到对应的值
    
16.     {
    
17.       temp->next_Area_Inf = p->next_Area_Inf;
    
18.       //释放内存空间
    : T- E4 ~) h( Q( z
19.       free(p->Area_Inf->Area_Data);
    
20.       free(p->Area_Inf);
    
21.       free(p);
    1 z+ Z% D5 Y! m. j' S* V1 g
22.       p=temp;
    
23.       res = true;
    
24.     }
    . t8 R$ p+ `2 |5 ~2 ^9 v
25.   }
    - b: S/ |, m9 j# |
26.   return res;
    ! v- T% T1 q5 s$ O4 z* d0 I
27. }

复制代码

看了上面的驱动函数，相信大家已经明白，大家可以自行编写一些驱动，下面我实现的三个简单函数。

$ k  ]; z: t$ h# H2 E1 M+ y/ K

1. /**
   
2. * @brief 根据区域ID找到链表
   ) B; I" d1 R4 v, \8 y9 E9 r
3. * @param data_p 链表指针
   4 Z' j1 B; I; k4 S. L8 e: Q
4. * @param num    区域ID编号
   
5. * @return int
   . a: G& i0 [( l5 \/ O$ A5 F
6. */
   & r. S5 d  a0 G% C- e$ l' o
7. int Find_Area_According_ID(Area_Inf_Typedef **data_p,int num)
   # `; ?% b* |8 {8 u8 K! \
8. {
   
9.   Area_List_Inf_Typedef *p =  Head_Area_List;
   + @  J  ?0 K% K4 F. K) e1 `* X
10.   while(p->next_Area_Inf!=NULL)
    5 Y! ]* Q9 _" {
11.   {
    
12.     p = p->next_Area_Inf;
    
13.     if(p->Area_Inf->ID == num)//匹配到对应的值
    2 a. `5 Y2 \- G  w
14.     {
    
15.       *data_p = p->Area_Inf;
    6 y3 Q, j4 o+ J/ H6 N
16.       return true;
    
17.     }
    0 ?4 y9 v3 V, ?% T' R, U0 d
18.   }
    0 Y/ _$ [3 S& ?3 b$ g- @+ R# c# m; a
19.   return false;
    * u+ I8 W) h; [: i7 E& `
20. }
    0 v# h/ h! [) ~7 e
21. /**
    
22. * @brief 删除所有区域
    
23. *
    
24. */
    9 A( `4 C8 g  S$ c$ H4 v
25. int Delete_All_Area(void)
    
26. {
    6 x4 t' u! T5 }1 U
27.   int res = false;
    7 i; K0 G# Q; y' I
28.   Area_List_Inf_Typedef *p =  Head_Area_List;
    / o& E3 j' p9 Y( K$ t
29.   while(p->next_Area_Inf!=NULL)
    
30.   {
    + V$ f5 @9 Z; n& T- b
31.     Area_List_Inf_Typedef *temp = p;
    
32.     p = p->next_Area_Inf;
    9 T* m8 _& B& [0 }" m: F
33.     temp->next_Area_Inf = p->next_Area_Inf;
    8 B- M+ h  z/ {  V6 X% X
34.     //释放内存空间
    ( T3 ]. Z% n  x' ~/ o' u% x
35.     free(p->Area_Inf->Area_Data);
    
36.     free(p->Area_Inf);
    
37.     free(p);
    & E+ L4 J) z8 Z4 g* g) P' v; J
38.     p=temp;
    # _0 I0 i8 P$ G7 m0 Q4 t8 p
39.     res = true;
    9 f' l( ?1 z! h4 Z. _3 C( p
40.   }
    
41.   return res;
    0 B  [! c9 R1 W* r7 B% C$ K
42. }
    6 `% q) _  D, G$ u; P
43. /**
    ( R2 L, q! d7 |" y) r2 ]
44. * @brief 打印链表信息
    9 h; N0 H+ t; p. S2 M
45. *
    * @4 Q4 n( I' y5 ?
46. */
    
47. void Printf_Area_Inf(void)
    
48. {
    8 f9 z0 l% _/ U9 l# B1 Z
49.   int i=0;
    8 d* h2 G( A& p% `
50.   Area_List_Inf_Typedef *p =  Head_Area_List;
    / Q0 U( T4 `+ N" ]% [' D
51.   printf("list   ID   X   Y   Width   Height   Area_Data\r\n");
    
52. 
    * j# L' M7 V' Q; q* P# C( N
53.   while(p->next_Area_Inf!=NULL)
    
54.   {
    
55.     p = p->next_Area_Inf;
    ( g1 U! A- N2 y, D# a) _
56.     printf(" %d     %d    %d   %d    %d      %d      %s\r\n",i,p->Area_Inf->ID,p->Area_Inf->X,p->Area_Inf->Y,p->Area_Inf->Width,p->Area_Inf->Height,p->Area_Inf->Area_Data);
    
57.     i++;
    9 g; f0 n8 i: q# t, Y1 E
58.   }  
    
59.   printf("----------------------end-----------------------\r\n");
    
60. }

复制代码

, w* N! Y7 E' c: {" {3 d) ~3、测试函数
下面编写一个测试函数，可以测试，链表的初始化，增加一个区域，删除指定区域，根据ID返回区域信息，删除所有区域接口。

1. /**
   
2. * @brief 链表测试函数
   
3. *
   
4. */
   
5. void list_main()
   
6. {
   : V  |0 D8 Y/ I6 B+ \+ J+ v
7.   int i,j;
   % L: s1 i1 L0 t2 S( ]: U
8.   Area_Inf_Typedef temp;
   ; W2 c2 j$ X' Y9 ^
9.   Area_Inf_Typedef **data_p;
   
10.   data_p = NULL;
    * z. n$ B% y6 p
11.   printf("------------------List test---------------------\r\n");
    
12.   if(!Area_List_Init( ))
    
13.   {
    
14.     printf("Memory fail..\r\n");
    , A5 h; a% ^2 H! ^- [4 M' V) E
15.   }
    / p% R! D0 N0 j0 Q9 b2 P
16.   for(i=0;i<5;i++)
    
17.   {
    : H% S5 q/ H8 z* q9 L
18.     temp.ID = i;
    % v2 O/ }6 m  ?- ~2 t7 B
19.     temp.X = 5+i;
    , Q3 [. k' p. \* h( A* ^
20.     temp.Y = i;
    
21.     temp.Width = 10+i;
    4 J4 M# f; {) z8 q( _
22.     temp.Height = 10+i;
    
23.     temp.data_len = i+1;
    8 |2 f8 j  G2 L) _
24.     temp.Area_Data = (uint8_t*)malloc(temp.data_len+1);
    
25.     for(j=0;j<temp.data_len;j++)
    
26.     {
    
27.       temp.Area_Data[j] = j+0x30;
    
28.     }
    
29.     temp.Area_Data[j] = 0;
    
30.     if(!Add_Area_ToList(&temp))
    
31.     {
    . F. U( [( ~. Q5 d8 J$ \$ u) B/ ^4 u
32.       printf("Add Area %d Area_Info fail\r\n",i);
    
33.     }
    
34.   }
    ' W+ d; n; x3 h2 a2 I
35. 
    % T2 Q6 R. r! O0 ]
36.   Printf_Area_Inf();
    6 |1 x, k$ y/ H8 ^( f. |
37.   printf("\r\n-------------Delete ID of Area is 3-------------\r\n");
    6 a# m  z. x+ C0 L4 I
38.   Delete_Area_Accordingn_ID(3);
      m6 W2 a+ G7 @1 u
39.   Printf_Area_Inf();
    " }* q" P& }5 m8 R3 E
40. 
    
41.   temp.ID = 9;
    
42.   temp.data_len = 10;
    
43.   temp.Area_Data = (uint8_t*)malloc(temp.data_len+1);
    
44.   for(j=0;j<temp.data_len;j++)
    
45.   {
    
46.     temp.Area_Data[j] = j+0x30;
    $ H1 {- W) L2 L4 L
47.   }
    
48.   temp.Area_Data[j] = 0;
    & l. [+ ?& ?0 X' D. G+ ?* P7 R
49.   if(!Add_Area_ToList(&temp))
    
50.   {
    1 t8 x* n- D! W; G4 a
51.     printf("Add Area %d info fail\r\n",temp.ID);
    1 T8 i+ s6 Z3 s
52.   }
    , L) E9 r* G- c! `) m+ I& u
53.   printf("\r\n--------------Add ID of Area is 9---------------\r\n");
    
54.   Printf_Area_Inf();
    
55. 
    ! f, B# g# n9 k1 A4 L) g
56.   Find_Area_According_ID(data_p,2);
    
57.   temp.ID = (*data_p)->ID;
    8 U# d) W* a- o* n4 a8 M/ z  o
58. 
    0 I/ ~/ t3 f+ r! |7 a7 H
59.   Delete_All_Area();
    
60.   printf("\r\n--------------Delete All Area-------------------\r\n");
    ! e1 c" q4 m  R0 H7 l
61.   Printf_Area_Inf();
    
62. 
    
63.   while(1);
    ' `* B' }9 ~- v5 x3 d
64. }

复制代码

3 Q" h) ~9 M# i8 @4 ?4 `
% @7 g; F* c4 T# j测试结果
. x% `- D4 o& x  W$ B! e
1 }( ^/ t+ @$ q, i! F
- b3 ~  `  ]  S( T  K/ m; q' \* \

/ V2 j* w# _7 ^  ?' P如果大家手中有板子可以调试，可以看《一文了解串口打印》文章，使用串口打印。如果临时没有板子可以debug，可以模拟测试，IAR设置如下：

选择Simulator调试
: i8 w) X) \( ^. g( N$ E2 ^: M

3 w3 F8 I2 l* G, C! \0 L1 V
2 t4 j: I8 G  g: d: Q: U8 L打开View->TerminalI/O，就可以看到打印信息



' N, c2 |* h2 n0 S$ X