[016] [RT-Thread学习笔记] 链表源码分析

最新推荐文章于 2026-05-08 05:37:56 发布
原创 最新推荐文章于 2026-05-08 05:37:56 发布 · 1.1k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#链表 #学习 #数据结构 #rtos
本文详细介绍了RT-Thread中单向链表(SingleList)和双向链表(RT_List)的节点结构、初始化、插入、删除、判断表空等操作，并重点讲解了如何安全地遍历链表。通过实例展示了list_for_each与list_for_each_safe的区别。
RT-Thread
学习笔记
单向链表
双向链表
list_for_each与list_for_each_safe

RT-Thread版本：4.0.5
MCU型号：STM32F103RCT6（ARM Cortex-M3 内核）

rt-thread中的链表源码在rtservice.h中，以宏或者内联函数的形式给出，其中，list为双向链表，slist为单向链表。rt-thread链表主要是为了连接管理内核对象，因此并无数据域，仅有指针域。

1 单向链表

1.1 单向链表节点结构体

Single List structure定义在rtdef.h中：

struct rt_slist_node
{
    struct rt_slist_node *next;
};
typedef struct rt_slist_node rt_slist_t;

链表是一种递归定义的结构体，即自已定义自已，需要注意只能定义指向自己的指针，因为指针大小可以确定，如果直接定义，编译器不知道具体大小会报错。

1.2 初始化

初始化有两种方法：

  • 内联函数
rt_inline void rt_slist_init(rt_slist_t *l)
{
    l->next = RT_NULL;
}

显然，这是带头结点的单链表初始化方式，将头结点指针域置空。

  • 宏
#define RT_SLIST_OBJECT_INIT(object) { RT_NULL }

使用示例：

rt_slist_t sl_node = RT_SLIST_OBJECT_INIT(sl_node);
// 宏展开:
sl_node = {RT_NULL};
// 即:
sl_node = {.next = RT_NULL};

1.3 尾插

rt_inline void rt_slist_append(rt_slist_t *l, rt_slist_t *n)
{
    struct rt_slist_node *node;
	
    node = l;
    // 遍历链表至表尾节点
    while (node->next) node = node->next;
	// 表尾节点指针域指向新插入节点
    node->next = n;
    // 新节点指针域置空
    n->next = RT_NULL;
}

l：链表头指针

n：待插入的节点指针

注意：不能直接用头指针遍历链表，否则头指针最后将指向表尾，链表无法再使用。

1.4 头插

rt_inline void rt_slist_insert(rt_slist_t *l, rt_slist_t *n)
{
    // 新节点指针域指向首元节点(第一个节点)
    n->next = l->next;
    // 将头节点指针域指向新节点，新节点成为首元节点
    l->next = n;
}

1.5 求表长

rt_inline unsigned int rt_slist_len(const rt_slist_t *l)
{
    unsigned int len = 0;
    // l->next为第一个节点
    const rt_slist_t *list = l->next;
    while (list != RT_NULL)
    {
        list = list->next;
        len ++;
    }

    return len;
}

const修饰指向表头结点的指针，表明求表长时不能修改原链表。

1.6 删除指定节点

rt_inline rt_slist_t *rt_slist_remove(rt_slist_t *l, rt_slist_t *n)
{
    struct rt_slist_node *node = l;
    // 遍历链表找到要删除节点的位置
    while (node->next && node->next != n) node = node->next;
	// 如果没有遍历到最后一个节点, 说明找到删除节点的位置, 即当前节点的下一节点node->next
    if (node->next != (rt_slist_t *)0) 
        node->next = node->next->next;	// 将当前节点指针域指向删除节点的指针域, 即跳过删除节点

    return l;	// 返回修改后的链表
}

1.7 获取首元节点

rt_inline rt_slist_t *rt_slist_first(rt_slist_t *l)
{
    return l->next;
}

1.8 获取尾节点


rt_inline rt_slist_t *rt_slist_tail(rt_slist_t *l)
{
    while (l->next) l = l->next;

    return l;
}

1.9 获取当前节点下一个节点

rt_inline rt_slist_t *rt_slist_next(rt_slist_t *n)
{
    return n->next;
}

1.10 判断表空

rt_inline int rt_slist_isempty(rt_slist_t *l)
{
    return l->next == RT_NULL;	// 带头节点的单链表表空判断方法
}

1.11 单向链表相关宏

关于rt_container_of具体分析可参考：rt_list_entry函数

/**
 * @brief 根据单链表节点的地址，获取其所在type类型结构体的地址
 * @param node   入口节点地址
 * @param type   节点所在结构体的类型  
 * @param member 链表所在结构体中的链表变量的名称
 */
#define rt_slist_entry(node, type, member) \
    rt_container_of(node, type, member)

/**
 * 遍历单链表
 * @pos:    for循环中迭代变量(rt_slist_t *)
 * @head:   slist链表头结点
 */
#define rt_slist_for_each(pos, head) \
    for (pos = (head)->next; pos != RT_NULL; pos = pos->next)

/**
 * 遍历获取每个单链表节点所在type类型结构体的地址
 * typeof 运算符把类型信息作为字符串返回, typeof(*pos)即为当前节点指向的结构体类型的字符
 * @pos:    指向宿主结构的指针, 在for循环中是一个迭代变量(type*类型)
 * @head:   slist表头指针
 * @member: 链表所在结构体中的链表变量的名称
 */
#define rt_slist_for_each_entry(pos, head, member) \
    for (pos = rt_slist_entry((head)->next, typeof(*pos), member); \
         &pos->member != (RT_NULL); \
         pos = rt_slist_entry(pos->member.next, typeof(*pos), member))

/**
 * 获取表头元素所在结构体地址
 * @ptr:    slist表头指针
 * @type:   链表所在结构体的类型
 * @member: 链表所在结构体中的链表变量的名称
 * 注意：链表不能为空
 */
#define rt_slist_first_entry(ptr, type, member) \
    rt_slist_entry((ptr)->next, type, member)

/**
 * 获取表尾元素所在结构体地址
 * @ptr:    slist表头指针
 * @type:   链表所在结构体的类型
 * @member: 链表所在结构体中的链表变量的名称
 * 注意：链表不能为空
 */
#define rt_slist_tail_entry(ptr, type, member) \
    rt_slist_entry(rt_slist_tail(ptr), type, member)

2 双向链表

2.1 双向链表节点结构体

Single List structure定义在rtdef.h中：

struct rt_list_node
{
    struct rt_list_node *next;
    struct rt_list_node *prev;
};
typedef struct rt_list_node rt_list_t;

双向链表有两个指针域，next指向下一个节点，prev指向上一个节点。因为多了一个prev指针域，相对于单链表，其获取前驱结点比较方便（l->prev），时间复杂度为O(1)；而单链表则需要遍历查找，时间复杂度为O(n)。

2.2 初始化

  • 内联函数
rt_inline void rt_list_init(rt_list_t *l)
{
    l->next = l->prev = l;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ijUaZ9TG-1645286572274)(img/image-20220219214836118.png)]

双向非循环链表初始化是将l->next = l->prev = NULL;，而这种是双向循环链表初始化方法，即将头结点的前驱指针与后继指针均指向自身。

  • 宏
#define RT_LIST_OBJECT_INIT(object) { &(object), &(object) }

用法示例：

rt_list_t l_node = RT_LIST_OBJECT_INIT(l_node);
// 宏展开：
l_node = {&l_node, &l_node};
// 即：
l_node = {.next = &l_node, .prev = &l_node};

2.3 指定节点后插入

/**
 * @param l list to insert it
 * @param n new node to be inserted
 */
rt_inline void rt_list_insert_after(rt_list_t *l, rt_list_t *n)
{
    // 与当前节点的后一个节点连接
    l->next->prev = n;	// 1.将当前节点的后一个节点的prev指针指向新节点
    n->next = l->next;	// 2.将新节点的next指针指向当前节点的后一个节点
	// 与当前节点连接
    l->next = n;		// 3.将当前节点的next指针指向新节点
    n->prev = l;		// 4.将新节点的prev指针指向当前节点
}

在这里插入图片描述

图中Node1为当前节点，Node2当前节点的后一个节点

l为当前节点，n为插入在l后的新节点。双向链表插入相对单链表，需要修改两个方向上的指针，即当前节点l的next指针域（l->next），当前节点后一个节点的prev指针域（l->next->prev）。

2.4 指定节点前插入

/**
 * @param l list to insert it
 * @param n new node to be inserted
 */
rt_inline void rt_list_insert_before(rt_list_t *l, rt_list_t *n)
{
    // 与当前节点的前一个节点连接
    l->prev->next = n;	// 1.将当前节点的前一个节点的next指针指向新节点
    n->prev = l->prev;	// 2.将新节点的prev指针指向当前节点的前一个节点
	// 与当前节点连接
    l->prev = n;		// 3.将当前节点的prev指针指向新节点
    n->next = l;		// 4.将新节点的next指针指向当前节点
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c9L4Xevp-1645286572281)(img/image-20220219222209588.png)]

图中Node1为当前节点，Node3当前节点的前一个节点(Node1的prev指向它，这是一个双向循环链表，表尾next要指向表头，表头prev要指向表尾)

同时需要修改两个方向上的指针：当前节点l的prev指针域（l->prev），当前节点前一个节点的next指针域（l->prev->next）。

2.5 求表长

rt_inline unsigned int rt_list_len(const rt_list_t *l)
{
    unsigned int len = 0;
    const rt_list_t *p = l;
    // 循环链表可以从任意节点开始遍历求表长, 当当前节点next指针自身时，结束遍历
    while (p->next != l)
    {
        p = p->next;
        len ++;
    }

    return len;
}

2.6 删除指定节点

rt_inline void rt_list_remove(rt_list_t *n)
{
    n->next->prev = n->prev;	// 1.被删节点的后一个节点的prev指向被删结点的前一个结点
    n->prev->next = n->next;	// 2.被删节点的前一个节点next指向被删结点的后一个结点

    n->next = n->prev = n;		// 3.被删结点置空
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2gmC7TOh-1645286572283)(img/image-20220219220201507.png)]
同时需要修改两个方向上的指针：被删节点的后一个节点的prev指针域（n->next->prev），被删节点的前一个节点的next指针域（n->prev->next）。

2.7 判断表空

rt_inline int rt_list_isempty(const rt_list_t *l)
{
    return l->next == l;
}

2.8 双向链表相关宏

/**
 * @brief 根据双向链表节点的地址，获取其所在type类型结构体的地址
 * @param node   入口节点地址
 * @param type   节点所在结构体的类型  
 * @param member 节点在该结构体中的成员名称
 */
#define rt_list_entry(node, type, member) \
    rt_container_of(node, type, member)

/**
 * 遍历双向循环链表
 * @pos:	for循环中迭代变量(rt_list_t *类型)
 * @head:	表头
 */
#define rt_list_for_each(pos, head) \
    for (pos = (head)->next; pos != (head); pos = pos->next)

/**
 * 安全地遍历一个链表，防止遍历过程中删除链表元素引发的异常
 * @pos:    for循环中迭代变量(rt_list_t *类型)
 * @n:      临时存储节点pos变量(rt_list_t *类型)
 * @head:   表头
 */
#define rt_list_for_each_safe(pos, n, head) \
    for (pos = (head)->next, n = pos->next; pos != (head); \
        pos = n, n = pos->next)

/**
 * 遍历获取每个双向链表节点所在type类型结构体的地址
 * typeof 运算符把类型信息作为字符串返回, typeof(*pos)即为当前节点指向的结构体类型的字符
 * @pos:    指向宿主结构的指针, 在for循环中是一个迭代变量
 * @head:   表头指针
 * @member: 链表所在结构体中的链表变量的名称
 */
#define rt_list_for_each_entry(pos, head, member) \
    for (pos = rt_list_entry((head)->next, typeof(*pos), member); \
         &pos->member != (head); \
         pos = rt_list_entry(pos->member.next, typeof(*pos), member))
/**
 * 安全遍历获取每个双向链表节点所在type类型结构体的地址
 * typeof 运算符把类型信息作为字符串返回, typeof(*pos)即为当前节点指向的结构体类型的字符
 * @pos:    指向宿主结构的指针, 在for循环中是一个迭代变量(type*类型)
 * @n:      临时存储pos变量(type*类型)
 * @head:   表头指针
 * @member: 链表所在结构体中的链表变量的名称
 */
#define rt_list_for_each_entry_safe(pos, n, head, member) \
    for (pos = rt_list_entry((head)->next, typeof(*pos), member), \
         n = rt_list_entry(pos->member.next, typeof(*pos), member); \
         &pos->member != (head); \
         pos = n, n = rt_list_entry(n->member.next, typeof(*n), member))

/**
 * 获取表头元素所在结构体地址
 * @ptr:    表头指针
 * @type:   链表所在结构体的类型
 * @member: 链表所在结构体中的链表变量的名称
 * 注意：链表不能为空
 */
#define rt_list_first_entry(ptr, type, member) \
    rt_list_entry((ptr)->next, type, member)

3 list_for_each与list_for_each_safe

  • list_for_each遍历链表循环程序中，如果将当前pos指向的节点内存释放，那么该节点的前后指针将变为野指针。此外，rt_list_init(pos)和rt_list_remove(pos)将让pos指向的节点的前后指针指向自身，导致死循环。
  • list_for_each_safe被称为安全遍历，它的做法是：先将pos后继指针pos->next缓存到n，下次遍历时再将n赋给pos，同时让n = pos->next，这样避免了直接使用pos = pos->next引发的异常。

注意：这种安全遍历也仅对错误操作当前遍历的pos指针的节点有效，如果误操作其后面还未遍历到的节点，依然会出错。

测试代码：

rt_list_t l = RT_LIST_OBJECT_INIT(l);
rt_list_t l_node1 = RT_LIST_OBJECT_INIT(l_node1);
rt_list_t* l_node2 = new rt_list_t;
rt_list_t l_node3 = RT_LIST_OBJECT_INIT(l_node3);
int main(int* arac, char** argv)
{
	rt_list_init(l_node2);
	rt_list_insert_after(&l, &l_node1);
	rt_list_insert_after(&l_node1, l_node2);
	rt_list_insert_after(l_node2, &l_node3);

	cout << "l_node1:" << &l_node1 << endl;
	cout << "l_node2:"  << l_node2 << endl;
	cout << "l_node3:"  << &l_node3 << endl;
	cout << "-------------------" << endl;

	rt_list_t* node_ptr = &l_node1;
	rt_list_t* l_ptr = &l;
	rt_list_t* n_ptr;
	rt_list_for_each_safe(node_ptr, n_ptr, l_ptr)
//  rt_list_for_each(node_ptr, l_ptr)
    {
     cout << node_ptr << endl;
     // 非安全遍历会死循环 
	 // rt_list_remove(node_ptr);
	 // rt_list_init(node_ptr);
	 // 野指针 程序崩溃 
     if (node_ptr == l_node2 && node_ptr != NULL) {
         delete node_ptr;
         node_ptr = NULL;
     }
    }
	system("pause");

	return 0;
}
  • 死循环情况：
    rt_list_for_each：
    在这里插入图片描述
    rt_list_for_each_safe：
    在这里插入图片描述
  • 野指针情况：
    rt_list_for_each：
    在这里插入图片描述
    rt_list_for_each_safe：
    在这里插入图片描述

END

RT-Thread 隐藏的宝藏之单链表
whj123999的博客
01-30 2167
1. 链表与数组 链表 ，数组 ，先看看百度怎么说。 上面的说法太专业，用简单的话来讲就是：链表和数组都是用来存储数据的一种数据结构，各有利弊。 数组：线性数据结构，存放的数据的类型是一样的，而且他们在内存中的排布是有序排列的。因此数组的优势就是数据连续，随机访问速度快，定义好了就不好在改变大小. 单链表：由一个个节点(node)组成，每个节点都有指向下一个节点的指针。节点的连接方向是单向的，节点之间用指针连起来，所有结构体类型可以不一样，链表的大小也可以动态变化。但是不能随机访问数据，只能遍历。 举一个栗
RT_Thread内核源码分析(二)——链表和对象管理
langhunxiaoyue的博客
09-24 1298
本章基于RT_Thread Nano V3.1.5版本分析内核源码，主要分析链表管理和对象。
单片机项目避坑：DS1302时钟芯片的BCD码转换与数码管显示的那些细节
最新发布
weixin_30697239的博客
05-08 428
本文详细解析了单片机项目中DS1302时钟芯片与数码管显示的常见问题，包括BCD码转换、时序控制和显示优化等关键细节。特别针对蓝桥杯等竞赛场景，提供了实用的避坑指南和优化技巧，帮助开发者避免时间显示异常等典型错误。
RT-Thread内核中链表介绍
caihaitao2000的博客
04-24 1038
不管是学习分析FreeRTOS内核，还是学习分析RT-Thread内核源码；对内核中链表的相关定义的熟悉，以及API的使用是必不可少的。因为，在内核中很多其它组件的相关API函数，都要用到进行对象的管理。本文简要介绍RT-Thread Nano内核中双向循环链表和单向链表的定义，以及API相关源码分析。 1.双向循环链表介绍 双向循环链表结构体定义： /** * Double List structure * 双向循环链表结构体定义 */ struct rt_list_node { s
RT-Thread源码分析2：单链表
电子开发的经验笔记
10-18 774
文章目录前情提要RT-Thread单链表构造单链表节点数据结构双链表处理函数1. 初始化链表对象2. 初始化一个单链表3. 在单向链表l的尾部追加一个节点4. 向单向链表节点l后插入一个节点n5. 获取单向链表的长度6. 从单向链表l中移除一个节点n7. 获取单向链表的第一个节点8. 获取单向链表的最后一个节点9. 获取单向链表节点n的下一个节点10. 判断单向链表是否为空关于作者 前情提要 源码文件：RT-Thread Nano V3.1.3\include\rtservice.h （源文件修改日期：2
内核2-链表
qq_37932504的博客
04-26 1756
链表结构体定义 //定义双向链表节点结构体 struct rt_list_node { struct rt_list_node *next; /* 指向下一个节点 */ struct rt_list_node *prev; /* 指向前一个节点 */ }; typedef struct rt_list_node rt_list_t; /* 定义类型rt_l
rt-thread 单链表的用法
czjockey的博客
10-08 819
关于rt-thread 单链表，网上介绍实例很少。以下程序能跑，在此做记录。
链表之SLIST
车子（chezi）
02-13 4266
文章目录背景SLIST 简介接口和实现举例代码分析SLIST_ENTRY 和 SLIST_HEADSLIST_INITSLIST_INSERT_HEADSLIST_INSERT_AFTERSLIST_REMOVESLIST_FIRST 和 SLIST_REMOVE_HEADSLIST_FOREACHSLIST_EMPTY 和 SLIST_INIT附录 queue.h参考资料 背景 对于 C 语言，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。这样做不仅麻烦，且需要验证代码的正确性，对于每个阅读
RT-Thread源码-核心数据结构rt_list及rt_slist
qq_36535265的博客
05-05 1499
在RT-Thread中，基本上所有内核对象的实现都离不开，rt_list及rt_slist，这两个数据结构实际上就是普通的链表数据结构。 rt_list表示的是双向链表结构，而rt_slist表示的是单向链表结构，以下为这两个数据结构的实现： struct rt_list_node { struct rt_list_node *next; /**< point to next node. */ struct rt_list_node.
单向链表删除并清空操作 注意
猪哥的专栏
12-27 2520
在之前的文章《深入理解Linux内核之链表 list.h 功能实现原理、接口说明及示例代码》中详细的分析了链表的各种操作，我们经常使用的操作是“初始化”、“ 添加节点”、“遍历”、“删除”，对于链表节点的删除，使用的相对少，而且由于 删除操作的 宏函数 定义的复杂，容易混淆，本文基于此，对 链表的删除清空做下备忘录。 以单向链表结构 为例，用到的宏函数有2个，分别为： /* * I...
内核链表点滴--list_for_each_safe使用
zhangge3663的博客
06-19 3433
自己是个初学者,一直在学习国嵌的教程,本来是在本子上做的笔记,今天学习到内核链表了,老师留了个小问题,自己做了一下,算是写下自己的心得吧. 大牛们一定不要见笑... 源程序如下: #include <linux/kernel.h> #include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/list.h> MODULE_LI
rt-thread中的链表
victor_zy的博客
12-27 1553
链表 一般地，C语言实现双向链表是这样定义节点的 struct list_node { int data; struct list_node *prev; // 指向前一节点 struct list_node *next; // 指向后一节点 } 而在rt-thread中，链表定义是这样的： struct list_node { struct list_node *next; struct list_node *prev; }; 链表的操作是这样的： // 初始化环形链表 sta
单向链表(一)--单向链表操作函数
tyustli
01-12 976
1、单向链表的结构体定义 /** * Single List structure 单链表结构体 */ struct rt_slist_node { struct rt_slist_node *next; /**< point to next node. 指向下一个节点 */ }; typedef struct rt_slist_node rt_slis...
双向链表(二)--双向链表初始化的宏 RT_LIST_OBJECT_INIT
tyustli
01-10 752
1、定义 #define RT_LIST_OBJECT_INIT(object) { &(object), &(object) } 2、作用 RT_LIST_OBJECT_INIT用于初始化一个双向链表，使双向链表的前一个节点和后一个节点的指针均指向自己。 3、示例程序 #include <stdio.h> /** * @brief initial...
rt-thread的链表
k999的专栏
09-18 3314
rt-thread的链表 1.链表解释 借用网上的一些文章来描述一下什么是链表： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。由于不必须按
list_for_each_safe()
听
10-25 2242
<br />如果在遍历过程中，包含有删除或移动当前链接节点的操作，由于这些操作会修改遍历指针，这样会导致遍历的中端。这种情况下，必须使用list_for_each_safe宏，在操作之前将遍历指针缓存下来。内核中解释的精华部分：<br />/*<br /> list_for_each_safe                 -iterate over a list safe against removal of list entry<br />*/<br />#define list_for_each_s
内核6-时钟管理
qq_37932504的博客
08-20 1424
软件定时器：timer线程调用回调，rt_soft_timer_list，rt_thread_timer_entry线程 硬件定时器：ISR调用回调，rt_timer_list 停止：
RT-Thread 操作系统中链表的用法和相关函数的实现原理
艾格北峰嵌入式
09-11 800
RT-Thread 操作系统中链表的用法和相关函数的实现原理
RT-Thread 隐藏的宝藏之双链表
whj123999的博客
02-13 879
1. 单链表与双链表 单链表： 由一个个节点(node)组成，每个节点都有指向下一个节点的指针。节点的连接方向是单向的，节点之间用指针连起来，所有结构体类型可以不一样，链表的大小也可以动态变化。但是不能随机访问数据，只能遍历。 双链表：由一个个节点(node)组成，每个节点都有指向下一个节点的指针，每个节点都有一个指向上一个节点的指针。所以节点的连接方向是双向的，节点之间用指针连起来，所有结构体类型可以不一样，链表的大小也可以动态变化。但是不能随机访问数据，只能遍历。 可以得出结论：单链表和双链表主要的区别
rtt设备驱动框架学习——链表
rerrick_rose的博客
06-30 1469
这个宏的作用是通过结构体成员的指针 ptr 和成员名 member，计算出包含该成员的结构体的起始地址，并将其转换为 type 类型的指针。_inline函数也称为内联函数或内嵌函数，_inline定义的类的内联函数，函数代码被放入符号调用表，使用时直接展开，不需要调用，即在编译期间将所调用的函数的代码直接嵌入到主调函数中，是一种。(type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member))：将计算结果转换回 type 类型的指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柯西的彷徨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值