链表之STAILQ

最新推荐文章于 2024-02-27 22:42:19 发布
最新推荐文章于 2024-02-27 22:42:19 发布
阅读量2.8k 收藏 10
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 STAILQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longintchar/article/details/122907478
版权

文章目录

STAILQ 示意图

请添加图片描述

STAILQ 和 LIST 的不同是，head 里面有个指针 stqh_last，指向最后一个节点的 stqe_next

注意：有的地方也把 STAILQ 叫 simple queue，将接口前缀改为 SIMPLEQ_

接口和实现

先贴代码。（注意：不同版本的代码可能不同）

/*
 * Singly-linked Tail queue declarations.
 */
#define	STAILQ_HEAD(name, type)						\
struct name {								\
	struct type *stqh_first;/* first element */			\
	struct type **stqh_last;/* addr of last next element */		\
}

#define	STAILQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).stqh_first }

#define	STAILQ_ENTRY(type)						\
struct {								\
	struct type *stqe_next;	/* next element */			\
}

/*
 * Singly-linked Tail queue functions.
 */
#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)

#define	STAILQ_FIRST(head)	((head)->stqh_first)

#define	STAILQ_FOREACH(var, head, field)				\
	for((var) = STAILQ_FIRST((head));				\
	   (var);							\
	   (var) = STAILQ_NEXT((var), field))

#define	STAILQ_INIT(head) do {						\
	STAILQ_FIRST((head)) = NULL;					\
	(head)->stqh_last = &STAILQ_FIRST((head));			\
} while (0)

#define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
	STAILQ_NEXT((tqelm), field) = (elm);				\
} while (0)

#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
	STAILQ_FIRST((head)) = (elm);					\
} while (0)

#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
	STAILQ_NEXT((elm), field) = NULL;				\
	*(head)->stqh_last = (elm);					\
	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
} while (0)

#define	STAILQ_LAST(head, type, field)					\
	(STAILQ_EMPTY(head) ?						\
		NULL :							\
	        ((struct type *)					\
		((char *)((head)->stqh_last) - offsetof(struct type, field))))

#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)

#define	STAILQ_REMOVE(head, elm, type, field) do {			\
	if (STAILQ_FIRST((head)) == (elm)) {				\
		STAILQ_REMOVE_HEAD(head, field);			\
	}								\
	else {								\
		struct type *curelm = STAILQ_FIRST((head));		\
		while (STAILQ_NEXT(curelm, field) != (elm))		\
			curelm = STAILQ_NEXT(curelm, field);		\
		if ((STAILQ_NEXT(curelm, field) =			\
		     STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
			(head)->stqh_last = &STAILQ_NEXT((curelm), field);\
	}								\
} while (0)

#define	STAILQ_REMOVE_HEAD(head, field) do {				\
	if ((STAILQ_FIRST((head)) =					\
	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
		(head)->stqh_last = &STAILQ_FIRST((head));		\
} while (0)

#define	STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do {			\
	if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL)	\
		(head)->stqh_last = &STAILQ_FIRST((head));		\
} while (0)

#define STAILQ_REMOVE_AFTER(head, elm, field) do {			\
	if ((STAILQ_NEXT(elm, field) =					\
	     STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)	\
		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
} while (0)

举例

咱们看个例子，例子来自：https://manpages.courier-mta.org/htmlman3/stailq.3.html

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/queue.h>

struct entry {
    int data;
    STAILQ_ENTRY(entry) entries;        /* Singly linked tail queue */
};

STAILQ_HEAD(stailhead, entry);

int
main(void)
{
    struct entry *n1, *n2, *n3, *np;
    struct stailhead head;                  /* Singly linked tail queue
                                               head */

    STAILQ_INIT(&head);                     /* Initialize the queue */

    n1 = malloc(sizeof(struct entry));      /* Insert at the head */
    STAILQ_INSERT_HEAD(&head, n1, entries);

    n1 = malloc(sizeof(struct entry));      /* Insert at the tail */
    STAILQ_INSERT_TAIL(&head, n1, entries);

    n2 = malloc(sizeof(struct entry));      /* Insert after */
    STAILQ_INSERT_AFTER(&head, n1, n2, entries);

    STAILQ_REMOVE(&head, n2, entry, entries); /* Deletion */
    free(n2);

    n3 = STAILQ_FIRST(&head);
    STAILQ_REMOVE_HEAD(&head, entries);     /* Deletion from the head */
    free(n3);

    n1 = STAILQ_FIRST(&head);
    n1->data = 0;
    for (int i = 1; i < 5; i++) {
        n1 = malloc(sizeof(struct entry));
        STAILQ_INSERT_HEAD(&head, n1, entries);
        n1->data = i;
    }
                                            /* Forward traversal */
    STAILQ_FOREACH(np, &head, entries)
        printf("%i\n", np->data);
                                            /* TailQ deletion */
    n1 = STAILQ_FIRST(&head);
    while (n1 != NULL) {
        n2 = STAILQ_NEXT(n1, entries);
        free(n1);
        n1 = n2;
    }
    STAILQ_INIT(&head);

    exit(EXIT_SUCCESS);
}

代码分析

STAILQ_ENTRY 和 STAILQ_HEAD

struct entry {
    int data;
    STAILQ_ENTRY(entry) entries;        /* Singly linked tail queue */
};

STAILQ_HEAD(stailhead, entry);

宏替换后是

struct entry {
    int data;
    struct { 
        struct entry *stqe_next; 
    } entries;
};

struct stailhead { 
    struct entry *stqh_first; 
    struct entry **stqh_last; 
};

其实和 SLIST 差不多，唯一的不同是第 10 行，多了一个指向尾节点的指针（准确地说是指向尾节点的 stqe_next）

STAILQ_INIT 和 STAILQ_INSERT_HEAD

    struct entry *n1, *n2, *n3, *np;
    struct stailhead head;                  /* Singly linked tail queue
                                               head */

    STAILQ_INIT(&head);                     /* Initialize the queue */

    n1 = malloc(sizeof(struct entry));      /* Insert at the head */
    STAILQ_INSERT_HEAD(&head, n1, entries);

5：宏展开是

(&head)->stqh_first = ((void *)0); 
(&head)->stqh_last = &(&head)->stqh_first;

链表的初始化为空，stqh_first 等于 NULL，stqh_last 指向自己的 stqh_first

8：宏展开是

if (((n1)->entries.stqe_next = (&head)->stqh_first) == ((void *)0)) 
	(&head)->stqh_last = &(n1)->entries.stqe_next; 
(&head)->stqh_first = (n1);

把 n1 插入链表的第一个位置，会影响哪个指针的值呢？

  1. stqh_first
  2. n1 的 stqe_next
  3. 如果链表为空，那么插入 n1 后，stqh_last 也要改变

第 1 行解决了 2

第 2 行解决了 3

第 3 行解决了 1

STAILQ_INSERT_TAIL

    n1 = malloc(sizeof(struct entry));      /* Insert at the tail */
    STAILQ_INSERT_TAIL(&head, n1, entries);

2：宏替换是

    (n1)->entries.stqe_next = ((void *)0); 
    *(&head)->stqh_last = (n1); 
    (&head)->stqh_last = &(n1)->entries.stqe_next;

把 n1 插入链表的最后一个位置，会影响哪些指针的值呢？

  1. stqh_last
  2. n1 的 stqe_next，需要为 NULL
  3. 原先的最后一个节点（假设是 n8）的 stqe_next

第 1 行解决了 2

第 2 行有点麻烦，(&head)->stqh_last 指向 n8 节点的 stqe_next，*(&head)->stqh_last 就是 n8 节点的 stqe_next，赋值 n1 给它，解决了 3

第 3 行解决了 1

STAILQ_INSERT_AFTER

    n2 = malloc(sizeof(struct entry));      /* Insert after */
    STAILQ_INSERT_AFTER(&head, n1, n2, entries);

第 2 行的意思是把 n2 插入到 n1 的后面

代码展开后是

if (((n2)->entries.stqe_next = (n1)->entries.stqe_next) == ((void *)0)) 
    (&head)->stqh_last = &(n2)->entries.stqe_next; 
(n1)->entries.stqe_next = (n2);

把 n2 插入到 n1 的后面，会影响哪些指针的值呢？

  1. n1 的 stqe_next
  2. n2 的 stqe_next
  3. 如果 n2 是最后一个节点，还要修改 (&head)->stqh_last

第 1 行的 (n2)->entries.stqe_next = (n1)->entries.stqe_next) 解决了 2

第 3 行解决了 1

第 2 行解决了 3

STAILQ_REMOVE

    STAILQ_REMOVE(&head, n2, entry, entries); /* Deletion */
    free(n2);

第 1 行展开是，有点长

if ((&head)->stqh_first == (n2)) { 
    if ((((&head))->stqh_first = ((&head))->stqh_first->entries.stqe_next) == ((void *)0)) 
        ((&head))->stqh_last = &((&head))->stqh_first; 
} else { 
    struct entry *curelm = (&head)->stqh_first; 
    while (curelm->entries.stqe_next != (n2)) 
        curelm = curelm->entries.stqe_next; 
    if ((curelm->entries.stqe_next = curelm->entries.stqe_next->entries.stqe_next) == ((void *)0)) 
        (&head)->stqh_last = &(curelm)->entries.stqe_next; 
}

分 2 种情况。n2 是不是第一个节点（第 1 行代码），如果是，需要修改的指针有

  1. (&head)->stqh_first
  2. 如果 n2 是仅有的一个节点，那么还需要修改 (&head))->stqh_last

第 2 行的前半句解决了 1

第 3 行解决了 2

如果 n2 不是第一个节点，那就执行 5-10，先查找 n2 (6-7 行)，当找到的时候， curelm 代表 n2 前面的那个节点。此时需要修改的指针有：

  1. curelm 的 stqe_next
  2. 如果 n2 是最后一个节点，删除它后需要修改 (&head))->stqh_last

第 8 行的前半句解决了 1

第 9 行解决了 2

STAILQ_FIRST 和 STAILQ_REMOVE_HEAD

    n3 = STAILQ_FIRST(&head);
    STAILQ_REMOVE_HEAD(&head, entries);     /* Deletion from the head */
    free(n3);

STAILQ_FIRST 比较简单，就是取链表的第一个节点，注意，不是删除

第 1 行展开：n3 = ((&head)->stqh_first);

STAILQ_REMOVE_HEAD 是删除第一个节点

第 2 行展开：

if (((&head)->stqh_first = (&head)->stqh_first->entries.stqe_next) == ((void *)0)) 
    (&head)->stqh_last = &(&head)->stqh_first;

如果删除之前，仅有一个节点，那么需要修改 stqh_last，也就是第 2 行

如果有多个节点，那么只需要修改 stqh_first（第 1 行的前半句）

STAILQ_FOREACH

/* Forward traversal */
STAILQ_FOREACH(np, &head, entries)
	printf("%i\n", np->data);

STAILQ_FOREACH(np, &head, entries) 用来遍历链表的每个节点。第一个参数是临时变量，指向当前的节点，第二个参数是表头的地址，第三个 entries 是无标签结构体的成员名。

第 2 行展开：

 for ((np) = ((&head)->stqh_first); (np); (np) = ((np)->entries.stqe_next))
        printf("%i\n", np->data);

典型的遍历。注意，这种遍历是不能删除的，因为如果把 np 指向的节点删除了，

(np)->entries.stqe_next 这句就不对了。

STAILQ_NEXT

/* TailQ deletion */
    n1 = STAILQ_FIRST(&head);
    while (n1 != NULL) {
        n2 = STAILQ_NEXT(n1, entries);
        free(n1);
        n1 = n2;
    }

STAILQ_NEXT(n1, entries) 表示取 n1 的下一个节点

第 4 行展开是 n2 = ((n1)->entries.stqe_next); 比较简单。

这段代码也展示了如何删除整个链表。

还有几个宏，例子里面没有用到，我们也看一下。

STAILQ_EMPTY

#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)

这个很好理解，不解释了。

STAILQ_LAST

#define	STAILQ_LAST(head, type, field)					\
	(STAILQ_EMPTY(head) ?						\
		NULL :							\
	        ((struct type *)					\
		((char *)((head)->stqh_last) - offsetof(struct type, field))))

注意，我的 Linux 操作系统上，并不包含这个宏，所以，如果要用，需要手工把这段代码包含进去。

这个宏的意思找到队列的最后一个节点。它是这么用的：

n1 = STAILQ_LAST(&head, entry, entries);

本文开始的时候，有

struct entry {
    int data;
    STAILQ_ENTRY(entry) entries;        /* Singly linked tail queue */
};

STAILQ_HEAD(stailhead, entry);

n1 = STAILQ_LAST(&head, entry, entries) 的后两个参数要对应第 3 行的定义。

我们回头看 STAILQ_LAST 的代码

#define	STAILQ_LAST(head, type, field)					\
	(STAILQ_EMPTY(head) ?						\
		NULL :							\
	        ((struct type *)					\
		((char *)((head)->stqh_last) - offsetof(struct type, field))))

如果链表为空，就返回 NULL，如果不为空呢？当然是顺着 (head)->stqh_last 找对最后一个节点。

问题是，(head)->stqh_last 指向的是最后一个节点的 entries.stqe_next 域

struct entry {
    int data;
    struct { 
        struct entry *stqe_next; 
    } entries;
};

也就是第 4 行，(head)->stqh_last 的值是 struct entry *stqe_next 的地址，而不是 struct entry 的地址，所以需要转换一下。转换需要用到

offsetof(struct type, field)

这也是一个宏，代码大概在 /usr/src/linux-headers-4.8.0-36-generic/include/linux/stddef.h

#define offsetof(TYPE, MEMBER)	((size_t)&((TYPE *)0)->MEMBER)

这里的 TYPE 表示某个结构体类型，MEMBER 表示结构体中的一个成员，这个宏求出了成员在结构体中的位置偏移（以字节为单位）

假设一个结构体变量（类型是 struct entry）的起始地址是 0x1234，它里面有个成员是 data，请问 data 变量的地址是多少？

可以这样求：

&((struct entry *)0x1234)->data

->比类型转换的优先级高，所以要加括号。((struct entry *)0x1234)->data 就得到了成员，再取地址，得到成员的地址，再来一个类型转换，转成无符号整形：

(size_t)&((struct entry *)0x1234)->data

终于得到成员的起始地址了，这时候我们看看它对于结构体变量的起始地址的偏移是多少？也就是用成员的地址减去结构体变量的地址：

(size_t)&((struct entry *)0x1234)->data - 0x1234

不难看出，这里的 0x1234 换成什么数字都可以，因为偏移是一个相对量，和起始地址无关

为了简单，那就把 0x1234 换成 0 吧。

我们做一般化的处理，把 struct entry 叫 TYPE，把 data 叫 MEMBER，所以就有了

((size_t)&((TYPE *)0)->MEMBER)

咱们回到正题上来，(head)->stqh_last 的值是 struct entry *stqe_next 的地址，而不是 struct entry 的地址，*如果我们知道 struct entry stqe_next 相对于 struct entry 的偏移 x，那么用 (head)->stqh_last 减去 x 就可以了。

利用 offsetof(struct type, field) 来求偏移，同时注意到 struct entry *stqe_next 和 entries 是同一个地址，所以偏移是：offsetof(struct entry , entries )

最后一个节点的地址是：

(struct entry *)((char*)((head)->stqh_last) - offsetof(struct entry, entries)))

把上面这个式子一般化，entry 换成 type，entries 换成 field，就得到了代码中的：

 ((struct type *)					\
		((char *)((head)->stqh_last) - offsetof(struct type, field))))

其实还有更简单的方法，直接利用内核里面的 container_of 宏，这里只做个提示，就不展开了。

【end】

车子 chezi
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python数据结构之链表实现
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
直击面试之链表
01-20
面试过程中经常会遇到链表相关面试，链表相较于数组区别是节点存储空间不连续，可持续扩展。下面是使用Go进行链表实现。 链表结构定义 //define the data struct type LinkList struct { pPrev *LinkList //Previous node pointer pNext *LinkList //Next node pointer Value interface{} //Store The Value of Node } 链表的插入获取值 //Create Node func NewLinkList(value interface{}) *
C语言之线性链表1
08-08
//返回data元素#endif3.0、线性链表之List.cList.h的实现#include <stdio.h>#include <malloc.h>#in
sys/queue.h
qq_35782149的博客
03-15 936
queue 简介 SLIST( 单链表 ) STAILQ LIST （双向链表 ） SIMPLEQ (简单队列) TAILQ( 尾队列 ) CIRCLEQ （循环队列） 例程
STAILQ队列 : TAILQ_FOREACH
happylzs2008的专栏
06-20 2733
http://www.linuxhowtos.org/manpages/3/TAILQ_FOREACH.htm BSD mandoc NAME SLIST_EMPTYSLIST_ENTRYSLIST_FIRSTSLIST_FOREACHSLIST_FOREACH_SAFESLIST_HEADSLIST_HEAD_INITIALIZERSLIST_INITSLIST_IN...
关于SLIST，STAILQ，LIST，TAILQ，CIRCLEQ图示详解
u014028690的博客
03-23 1843
一，前述 由于接触蓝牙协议栈相关工作，涉及很多mbuf,mqueue的操作，其中不乏Berkeley queue的身影，故因此，深入了解一下链表以及队列相关操作，九几年的代码放在现在依旧经典，需要深入琢磨多次！该部分包含5个部分，单向链表，双向链表，队列，尾队列，环形队列。 （注：在此之后，将依赖此深入了解mbuf与mqueue） 文件索引地址：https://github.com/torvalds/linux/blob/master/drivers/scsi/aic7xxx/queue.h 二，Sing
203.系统函数_链表库STAILQ
写给自己的笔记
12-24 171
【代码】203.系统函数_链表库STAILQ。
深入理解TAILQ队列
程序狗的成长之路
05-14 7168
宏名称 操作 TAILQ_INIT 初始化队列 TAILQ_FOREACH 对队列进行遍历操作 TAILQ_INSERT_BEFORE 在指定元素之前插入元素 TAILQ_INSERT_TAIL 在队列尾部插入元素 TAILQ_EMPTY 检查队列是
ESP-IDF的STAILQ_INSERT_TAIL阅读笔记
qq_36785388的博客
12-25 3487
ESP-IDF有尾单链表插值宏定义解读笔记
STAILQ 队列api
happylzs2008的专栏
06-20 2397
https://www.freebsd.org/cgi/man.cgi?query=queue&sektion=3&manpath=freebsd-release-ports QUEUE(3) FreeBSD Library Functions Manual QUEUE(3) NAME SLIST_CLASS_ENTRY, SLIST_...
python数据结构之链表详解
09-21
主要为大家详细介绍了python数据结构之链表的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
双向链表之自己动手.py
12-25
python双向链表各种操作
Linux内核队列queue.h
最新发布
wkk的博客
02-27 637
文章目录一、简介二、SLIST单向无尾链表2.1 介绍2.2 操作2.3 例子三、STAILQ单向有尾链表四、LIST双向无尾链表五、TAILQ双向有尾链表六、CIRCLEQ循环链表七、queue源码参考 一、简介 queue.h是一个非常经典的文件，定义了一系列宏的操作，它定义了一系列的宏操作，实现了链表，尾队列和循环链表。 queue.h定义了5个基本的数据类型： 单向无尾链表 单向有尾链表 双向无尾链表 双向有尾链表 循环链表 queue相关链表/队列的使用流程为： 定义自己的结构体 在结构体中
Linux TAILQ队列
哈哈一笑
05-24 1733
链表删除节点，参考：关于TAILQ链表节点删除问题 #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <sys/queue.h> /* TAILQ_I...
【BSD数据库】SLIST | STAILQ | LIST | TAILQ
weixin_49929829的博客
01-17 624
BSD 库学习与总结：重要结构体与常用宏函数
数据结构之线性表(bsd, sys/queue.h)
Once_day的回忆
05-28 1096
线性表（linear list）存在唯一的头部数据和尾部数据，而且中间的每个数据都有一个前驱元素和后驱元素。线性表是有限个元素的序列，如一维数组和链表。每个数据元素可由若干个数据项构成。a1a2an−1ana1​a2​....an−1​an​**数据元素n即为线性表的长度。**也可以看到每个元素都有个确切的位置，并且长度也可根据需要增长和缩短。本文介绍的线性表以linux自带的为例子，该列表来自于FreeBSD中的一个头文件。
TAILQ 详解
u010386121的博客
05-17 2901
最近在看乐鑫ESP-ADF框架，发现该框架用到TAILQ 双向链表，于是我网上找了大量资料，总结这一篇东西。 定义： TAILQ 是链表结构，使用大量宏定义去代表链表结构处理，源码在#include <sys/queue.h> 常用API TAILQ_HEAD 定义队列头 TAILQ_ENTRY 队列实体定义 TAILQ_INIT 初始化队列 TAILQ_FOREACH 对队列进行遍历操作 TAILQ_INSERT_BEFORE ..
Linux内嵌链表（sys/queue.h）详解
tissar的博客
02-11 1万+
Linux 内嵌链表（sys/queue.h）详解queue 简介SLISTSTAILQLISTTAILQCIRCLEQ例程 queue 简介 C语言不像C++语言可以使用STL，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。不统一的编程规范会增加代码的阅读难度，而且链表的正确性需要验证。 头文件queue.h为C语言中的链表提供了更加标准规范的编程接口。如今的版本多为伯克利加州大...
二分查找的递归和非递归算法（C语言实现）
热门推荐
车子（chezi）
01-06 1万+
二分查找的用途 二分查找又称折半查找，它用来解决“在一堆数中找出指定的数（也可能找了，发现没有）”这类问题。 二分查找的应用条件 要应用二分查找，这“一堆数”必须有以下特征： 存储在数组中 有序排列 所以，如果数是用链表存储的，那就无法在其上应用二分查找。 至于是升序排列还是降序排列、数组中是否存在相同的元素都不要紧。在本文的实验中，我们使数组递增排列，且数组中的元素互不相同。
c语言数据结构之链表
11-03
链表是一种常见的数据结构，它在计算机科学中有广泛的应用。在C语言中，链表常常用于实现动态内存分配、函数调用栈、多项式运算等问题。单向链表是一种基本的链表结构，它由一系列节点组成，每个节点包含一个数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值