RT-Thread-C语言知识点：链表的地址与初始化RT-Thread问答社区

C语言知识点：链表的地址与初始化

发布于 2021-08-03 23:27:05 浏览：1362 订阅该版

[tocm]

[RT-Thread 入门学习笔记 - 目录](https://club.rt-thread.org/ask/article/3420.html)

## 前言

- C语言的知识点非常的多，这里粗浅的了解一下链表相关的知识。

- 链表是一个数据结构，结构体 struct，链表定义的链表对象，本身占用内存空间，有自己的地址

- 链表的成员，可以含有用户数据域，或者只有一个指针变量成员，指针变量指向的类型，一般是自身链表结构体的类型。

- 链表就像自行车的链条一样连接起来，内存地址可以连续，也可以不连续。

## 单向链表的定义

- 定义一个结构体，只需要一个指针成员即可。

- 如RT-Thread的单链表定义：

```c
/**
 * Single List structure
 */
struct rt_slist_node
{
    struct rt_slist_node *next;                         /**< point to next node. */
};
typedef struct rt_slist_node rt_slist_t;                /**< Type for single list. */
```

- 这个链表没有数据域，直接使用并连接起来，没有实际意思。

- 一般使用时，用户自己定义好结构体，只需要增加一个rt_slist_t 结构体成员即可。

## 双向链表的定义

- 单向链表只有一个成员next（下一个），指向下一个链表节点，无法获取上一个链表的节点的地址。

- 双向链表，增加一个成员prev（前一个），可以前后两个方向访问其他的链表节点。

- RT-Thread 双向链表的定义也很简单，没有用户的数据域

```c
/**
 * Double List structure
 */
struct rt_list_node
{
    struct rt_list_node *next;                          /**< point to next node. */
    struct rt_list_node *prev;                          /**< point to prev node. */
};
typedef struct rt_list_node rt_list_t;                  /**< Type for lists. */
```

- 使用时，只需要把这个链表结构体作为用户结构体的一个成员即可。这样，通过链表的连接，实现了结构体的链式结构。

## 链表的地址

- 链表是一个数据结构实体，所以自身占用内存，拥有自己的地址。

- 链表多定义为全局变量，防止链表节点地址的无效，造成整个链式结构的破坏。

- RT-Thread链表本身的地址，链表第一个成员的地址相同。

### 测试函数如下：

```c
#include <rtthread.h>
 
void dump_list_address(void)
{
    rt_list_t dlist_t0 = { 0 };
    rt_slist_t slist_t1 = { 0 };
 
    rt_kprintf("|---- before init -----|\n");
    rt_kprintf("[dlist_t0] addr = 0x%08x\n", &dlist_t0);
    rt_kprintf("[dlist_t0.next] addr = 0x%08x\n", &dlist_t0.next);
    rt_kprintf("[dlist_t0.prev] addr = 0x%08x\n", &dlist_t0.prev);
    rt_kprintf("[slist_t1] addr = 0x%08x\n", &slist_t1);
    rt_kprintf("[slist_t1.next] addr = 0x%08x\n", &slist_t1.next);
 
    rt_list_init(&dlist_t0);
    rt_slist_init(&slist_t1);
 
    rt_kprintf("|---- after init -----|\n");
    rt_kprintf("[dlist_t0] addr = 0x%08x\n", &dlist_t0);
    rt_kprintf("[dlist_t0.next] addr = 0x%08x\n", &dlist_t0.next);
    rt_kprintf("[dlist_t0.prev] addr = 0x%08x\n", &dlist_t0.prev);
    rt_kprintf("[slist_t1] addr = 0x%08x\n", &slist_t1);
    rt_kprintf("[slist_t1.next] addr = 0x%08x\n", &slist_t1.next);
}
 
void dump_list_values(void)
{
    rt_list_t dlist_t0 = { 0 };
    rt_slist_t slist_t1 = { 0 };
 
    rt_kprintf("[dlist_t0] addr = 0x%08x\n", &dlist_t0);
    rt_kprintf("[slist_t1] addr = 0x%08x\n", &slist_t1);
    rt_kprintf("|---- before init -----|\n");
    rt_kprintf("[dlist_t0.next] = 0x%08x\n", dlist_t0.next);
    rt_kprintf("[dlist_t0.prev] = 0x%08x\n", dlist_t0.prev);
    rt_kprintf("[slist_t1.next] = 0x%08x\n", slist_t1.next);
 
    rt_list_init(&dlist_t0);
    rt_slist_init(&slist_t1);
 
    rt_kprintf("|----  after init -----|\n");
    rt_kprintf("[dlist_t0.next] = 0x%08x\n", dlist_t0.next);
    rt_kprintf("[dlist_t0.prev] = 0x%08x\n", dlist_t0.prev);
    rt_kprintf("[slist_t1.next] = 0x%08x\n", slist_t1.next);
}
 
MSH_CMD_EXPORT(dump_list_address, dump_list_address);
MSH_CMD_EXPORT(dump_list_values, dump list values);
```

### 测试结果

```c
msh >dump_list_address
|---- before init -----|
[dlist_t0] addr = 0x200028a4
[dlist_t0.next] addr = 0x200028a4 /* 双向链表第一个成员地址 */
[dlist_t0.prev] addr = 0x200028a8
[slist_t1] addr = 0x200028a0
[slist_t1.next] addr = 0x200028a0 /* 单向链表第一个成员地址 */
|---- after init -----|
[dlist_t0] addr = 0x200028a4
[dlist_t0.next] addr = 0x200028a4
[dlist_t0.prev] addr = 0x200028a8
[slist_t1] addr = 0x200028a0
[slist_t1.next] addr = 0x200028a0
 
 
msh >dump_list_values
[dlist_t0] addr = 0x200028a4
[slist_t1] addr = 0x200028a0
|---- before init -----|
[dlist_t0.next] = 0x00000000
[dlist_t0.prev] = 0x00000000
[slist_t1.next] = 0x00000000
|----  after init -----|
[dlist_t0.next] = 0x200028a4
[dlist_t0.prev] = 0x200028a4
[slist_t1.next] = 0x00000000
```

- 链表的成员是一个指针变量，指针成员，依旧有自己的地址，注意不是指针变量的值，是指针变量的地址。

- 结构体的入口地址，一般与第一个结构体成员的地址相同。

- RT-Thread 单链表初始化，只需要把成员next置为NULL即可。

- RT-Thread双向链表初始化，next 、prev成员，指向自身，也就是初值为自身的地址。

## 小结

- 认识结构体：链表，只是一个结构体而已。

- 注意区分概念：结构体的入口地址（本身地址），成员的地址（指针变量的地址），成员指向的地址（指针变量的值）。

- 熟悉链表的初始化，为后面进一步的操作，如插入、删除等，做好准备。

## 小常识

- 结构体的成员，类型可以是各种类型，包括结构体类型。

- 指针变量在固定的平台上，占用的大小是固定的，如32位平台，占用32位，4个字节，各种的指针变量，包括一个字符（char）指针、函数指针、结构体指针，占用内存的大小通通都是相同的。