libevent中的基本数据结构

最新推荐文章于 2024-03-14 19:50:30 发布
最新推荐文章于 2024-03-14 19:50:30 发布
阅读量1.3k 收藏 3
点赞数
分类专栏： 高性能网络通信框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiexingshishu/article/details/45510045
版权


libevent中文件queue.h文件包含5种数据结构：单链表，双向链表，队列，尾队列，环形队列。在处理I/O和signal中的事件时，用的就是尾队列，下面就介绍这几种数据结构

1、单链表

链表头用宏SLIT_HEAD来定义


#define SLIST_HEAD(name, type)						\
struct name {								\
	struct type *slh_first;	/* first element */			\
}

链表中的元素用宏SLIST_ENTRY定义

#define SLIST_ENTRY(type)						\
struct {								\
	struct type *sle_next;	/* next element */			\
}

单链表的逻辑结构图表示为




包含的操作有元素后插入，头部插入，头部删除


元素后插入宏定义

#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
	(slistelm)->field.sle_next = (elm);				\
} while (0)

头部插入

#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
	(elm)->field.sle_next = (head)->slh_first;			\
	(head)->slh_first = (elm);					\
} while (0)

头部删除

#define	SLIST_REMOVE_HEAD(head, field) do {				\
	(head)->slh_first = (head)->slh_first->field.sle_next;		\
} while (0)

2、双链表

双链表头宏定义为

#define LIST_HEAD(name, type)						\
struct name {								\
	struct type *lh_first;	/* first element */			\
}

双链表中元素宏定义为

#define LIST_ENTRY(type)						\
struct {								\
	struct type *le_next;	/* next element */			\
	struct type **le_prev;	/* address of previous next element */	\  //前一个成员le_next的地址
}

逻辑结构图为



元素后插入


#define LIST_INSERT_AFTER(listelm, elm, field) do {			\
	if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)	\
		(listelm)->field.le_next->field.le_prev =		\
		    &(elm)->field.le_next;				\
	(listelm)->field.le_next = (elm);				\
	(elm)->field.le_prev = &(listelm)->field.le_next;		\
} while (0)

逻辑结构图为



元素前插入


#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
	(elm)->field.le_prev = (listelm)->field.le_prev;		\
	(elm)->field.le_next = (listelm);				\
	*(listelm)->field.le_prev = (elm);				\
	(listelm)->field.le_prev = &(elm)->field.le_next;		\
} while (0)

列表头插入

#define LIST_INSERT_HEAD(head, elm, field) do {				\
	if (((elm)->field.le_next = (head)->lh_first) != NULL)		\
		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
	(head)->lh_first = (elm);					\
	(elm)->field.le_prev = &(head)->lh_first;			\
} while (0)

元素删除

#define LIST_REMOVE(elm, field) do {					\
	if ((elm)->field.le_next != NULL)				\
		(elm)->field.le_next->field.le_prev =			\
		    (elm)->field.le_prev;				\
	*(elm)->field.le_prev = (elm)->field.le_next;			\
} while (0)

元素替换

#define LIST_REPLACE(elm, elm2, field) do {				\
	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
		(elm2)->field.le_next->field.le_prev =			\
		    &(elm2)->field.le_next;				\
	(elm2)->field.le_prev = (elm)->field.le_prev;			\
	*(elm2)->field.le_prev = (elm2);				\
} while (0)


3、简单队列

简单队列主要包含头插入，尾插入，元素后插入，头删除操作

/*
 * Simple queue definitions.
 */
 //简单队列头定义
#define SIMPLEQ_HEAD(name, type)					\
struct name {								\
	struct type *sqh_first;	/* first element */			\
	struct type **sqh_last;	/* addr of last next element */		\
}

//队列头初始化，sqh_first=NULL, sqh_last=&sql_first
#define SIMPLEQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).sqh_first }

//简单队列元素定义
#define SIMPLEQ_ENTRY(type)						\
struct {								\
	struct type *sqe_next;	/* next element */			\
}

/*
 * Simple queue access methods.
 */
#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)  //队列头
#define	SIMPLEQ_END(head)	    NULL				//队列尾
#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))  //队列空的判断
#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)  //队列元素的下一个元素

//简单队列遍历
#define SIMPLEQ_FOREACH(var, head, field)				\
	for((var) = SIMPLEQ_FIRST(head);				\
	    (var) != SIMPLEQ_END(head);					\
	    (var) = SIMPLEQ_NEXT(var, field))

/*
 * Simple queue functions.
 */
 //简单队列初始化
#define	SIMPLEQ_INIT(head) do {						\
	(head)->sqh_first = NULL;					\
	(head)->sqh_last = &(head)->sqh_first;				\
} while (0)

//简单队列头插入元素
#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
		(head)->sqh_last = &(elm)->field.sqe_next;		\
	(head)->sqh_first = (elm);					\
} while (0)

//简单队列尾插入元素
#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.sqe_next = NULL;					\
	*(head)->sqh_last = (elm);					\
	(head)->sqh_last = &(elm)->field.sqe_next;			\
} while (0)

//简单队列元素后插入元素
#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
		(head)->sqh_last = &(elm)->field.sqe_next;		\
	(listelm)->field.sqe_next = (elm);				\
} while (0)

//队列头部删除元素
#define SIMPLEQ_REMOVE_HEAD(head, elm, field) do {			\
	if (((head)->sqh_first = (elm)->field.sqe_next) == NULL)	\
		(head)->sqh_last = &(head)->sqh_first;			\
} while (0)


4、尾队列

尾队列中主要包含队列头插入，尾插入，元素后插入，元素前插入，元素删除，元素替换。libevent中用到的队列其实也是尾队列

/*
 * Tail queue definitions.
 */
 //尾队列头定义，其中tqh_last表示最后一个元素的地址
#define TAILQ_HEAD(name, type)						\
struct name {								\
	struct type *tqh_first;	/* first element */			\
	struct type **tqh_last;	/* addr of last next element */		\
}

//队列初始化
#define TAILQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).tqh_first }

//队列元素定义
#define TAILQ_ENTRY(type)						\
struct {								\
	struct type *tqe_next;	/* next element */			\
	struct type **tqe_prev;	/* address of previous next element */	\
}

/*
 * tail queue access methods
 */
#define	TAILQ_FIRST(head)		((head)->tqh_first)   //队列中的第一个元素
#define	TAILQ_END(head)			NULL				//队列结束
#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next) //队列中当前元素的下一个元素
#define TAILQ_LAST(head, headname)					\   //两级队列，即第一队列中的每一个元素又是一个队列
	(*(((struct headname *)((head)->tqh_last))->tqh_last))
/* XXX */
#define TAILQ_PREV(elm, headname, field)				\
	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
#define	TAILQ_EMPTY(head)						\   //队列是否为空
	(TAILQ_FIRST(head) == TAILQ_END(head))  

//队列遍历
#define TAILQ_FOREACH(var, head, field)					\  
	for((var) = TAILQ_FIRST(head);					\
	    (var) != TAILQ_END(head);					\
	    (var) = TAILQ_NEXT(var, field))

//二级队列遍历
#define TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
	for((var) = TAILQ_LAST(head, headname);				\
	    (var) != TAILQ_END(head);					\
	    (var) = TAILQ_PREV(var, headname, field))

/*
 * Tail queue functions.
 */
 //队列初始化
#define	TAILQ_INIT(head) do {						\
	(head)->tqh_first = NULL;					\
	(head)->tqh_last = &(head)->tqh_first;				\
} while (0)

//队列头插入元素
#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
		(head)->tqh_first->field.tqe_prev =			\
		    &(elm)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm)->field.tqe_next;		\
	(head)->tqh_first = (elm);					\
	(elm)->field.tqe_prev = &(head)->tqh_first;			\
} while (0)

//队列尾插入元素
#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.tqe_next = NULL;					\
	(elm)->field.tqe_prev = (head)->tqh_last;			\
	*(head)->tqh_last = (elm);					\
	(head)->tqh_last = &(elm)->field.tqe_next;			\
} while (0)

//队列元素后插入元素
#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
		(elm)->field.tqe_next->field.tqe_prev =			\
		    &(elm)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm)->field.tqe_next;		\
	(listelm)->field.tqe_next = (elm);				\
	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
} while (0)


//队列元素前插入
#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
	(elm)->field.tqe_next = (listelm);				\
	*(listelm)->field.tqe_prev = (elm);				\
	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
} while (0)

//队列元素删除
#define TAILQ_REMOVE(head, elm, field) do {				\
	if (((elm)->field.tqe_next) != NULL)				\
		(elm)->field.tqe_next->field.tqe_prev =			\
		    (elm)->field.tqe_prev;				\
	else								\
		(head)->tqh_last = (elm)->field.tqe_prev;		\
	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
} while (0)

//队列元素替换
#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\
		(elm2)->field.tqe_next->field.tqe_prev =		\
		    &(elm2)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm2)->field.tqe_next;		\
	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
	*(elm2)->field.tqe_prev = (elm2);				\
} while (0)

5、环形队列

操作包含元素前插入， 元素后插入，头插入，尾接入，元素删除，元素替换

/*
 * Circular queue definitions.
 */
 //队列头定义
#define CIRCLEQ_HEAD(name, type)					\
struct name {								\
	struct type *cqh_first;		/* first element */		\
	struct type *cqh_last;		/* last element */		\
}

//队列头初始化
#define CIRCLEQ_HEAD_INITIALIZER(head)					\
	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }

//队列元素定义
#define CIRCLEQ_ENTRY(type)						\
struct {								\
	struct type *cqe_next;		/* next element */		\
	struct type *cqe_prev;		/* previous element */		\
}

/*
 * Circular queue access methods
 */
#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)   //环形队列中的第一个元素
#define	CIRCLEQ_LAST(head)		((head)->cqh_last)	//环形队列中的最后一个元素
#define	CIRCLEQ_END(head)		((void *)(head))
#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)   //下一个元素
#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)   //前一个元素
#define	CIRCLEQ_EMPTY(head)					\    //环形队列是否为空
	(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))

//环形队列遍历
#define CIRCLEQ_FOREACH(var, head, field)				\
	for((var) = CIRCLEQ_FIRST(head);				\
	    (var) != CIRCLEQ_END(head);					\
	    (var) = CIRCLEQ_NEXT(var, field))

//环形队列反向遍历		
#define CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
	for((var) = CIRCLEQ_LAST(head);					\
	    (var) != CIRCLEQ_END(head);					\
	    (var) = CIRCLEQ_PREV(var, field))

/*
 * Circular queue functions.
 */
 //环形队列初始化
#define	CIRCLEQ_INIT(head) do {						\
	(head)->cqh_first = CIRCLEQ_END(head);				\
	(head)->cqh_last = CIRCLEQ_END(head);				\
} while (0)

//元素后插入
#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
	(elm)->field.cqe_prev = (listelm);				\
	if ((listelm)->field.cqe_next == CIRCLEQ_END(head))		\
		(head)->cqh_last = (elm);				\
	else								\
		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
	(listelm)->field.cqe_next = (elm);				\
} while (0)

//元素前插入
#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
	(elm)->field.cqe_next = (listelm);				\
	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
	if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))		\
		(head)->cqh_first = (elm);				\
	else								\
		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
	(listelm)->field.cqe_prev = (elm);				\
} while (0)

//队列头插入
#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
	(elm)->field.cqe_next = (head)->cqh_first;			\
	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
	if ((head)->cqh_last == CIRCLEQ_END(head))			\
		(head)->cqh_last = (elm);				\
	else								\
		(head)->cqh_first->field.cqe_prev = (elm);		\
	(head)->cqh_first = (elm);					\
} while (0)

//队列尾插入
#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
	(elm)->field.cqe_prev = (head)->cqh_last;			\
	if ((head)->cqh_first == CIRCLEQ_END(head))			\
		(head)->cqh_first = (elm);				\
	else								\
		(head)->cqh_last->field.cqe_next = (elm);		\
	(head)->cqh_last = (elm);					\
} while (0)

//元素删除
#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
	if ((elm)->field.cqe_next == CIRCLEQ_END(head))			\
		(head)->cqh_last = (elm)->field.cqe_prev;		\
	else								\
		(elm)->field.cqe_next->field.cqe_prev =			\
		    (elm)->field.cqe_prev;				\
	if ((elm)->field.cqe_prev == CIRCLEQ_END(head))			\
		(head)->cqh_first = (elm)->field.cqe_next;		\
	else								\
		(elm)->field.cqe_prev->field.cqe_next =			\
		    (elm)->field.cqe_next;				\
} while (0)

//元素替换
#define CIRCLEQ_REPLACE(head, elm, elm2, field) do {			\
	if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==		\
	    CIRCLEQ_END(head))						\
		(head).cqh_last = (elm2);				\
	else								\
		(elm2)->field.cqe_next->field.cqe_prev = (elm2);	\
	if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==		\
	    CIRCLEQ_END(head))						\
		(head).cqh_first = (elm2);				\
	else								\
		(elm2)->field.cqe_prev->field.cqe_next = (elm2);	\
} while (0)



















kgduu
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Libevent源码分析-----TAILQ_QUEUE队列
luotuo44的专栏
08-04 1万+
Libevent源码中有一个queue.h文件，位于compat/sys目录下。该文件里面定义了5个数据结构，其中TAILQ_QUEUE是使得最广泛的。本文就说一下这个数据结构。 TAILQ_QUEUE由下面两个结构体一起配合工作。
Libevent---数据结构
qq_41983709的博客
12-30 320
1. 事件处理对象--event Libevent中事件处理对象是event结构类型。event结构体封装了句柄、事件类型、回调函数，以及其他必要的标志和数据。 struct event { // 事件回调结构 struct event_callback ev_evcallback; /* for managing timeouts */ //如果是超时事件，则表明是小根堆还是通用超时队列 union { TAILQ_ENTRY(even..
libevent的结构体struct event
最新发布
luosuss的博客
03-14 917
1 创建根（地基）节点--event_base_new();2 设置监听事件和数据可读可写的事件的回调函数；设置了事件对应的回调函数后，当事件产生的时候会自动调用回调函数3 进入事件循环--event_base_dispatch（）；相当于while(1),在循环内部等待事件的发生，若有事件发生会触发事件对应的回调函数。4 释放地基--event_base_free();释放地基。
libevent中的基本数据结构---queue.h
weixin_33777877的博客
03-22 91
1 /* 2 * List definitions. 3 * 双链表结构 4 */ 5 #define LIST_HEAD(name, type) \ 6 struct name { \ 7 struct type *lh_first; /* fi...
libevent主要的数据结构（一）
chong232的专栏
06-17 1853
（草草看了下，记录下来，作为以后的参考）libevent实现了网络IO,timer,signal的事件触发机制. 可以很方便的应用于event-driven服务器中,作为其底层事件处理模块. 比较成功的案例有 memcache(分布式缓存), PLB(负载均衡器)等.1. 用户需要完成的回调函数的定义void (*ev_callback)(int, short, void *arg);这个回调函数的参数的意思为:参数1: 表示触发事件的文件句柄,比如一个socket对象.参数2: 表示事件发生的结果,可能是
Libevent数据结构分析
heeyw的专栏
09-18 1055
Libevent数据结构分析： queue_head_t队列头 #define TAILQ_HEAD(name, type)                      \   struct name {                               \       struct type *tqh_first; /* first element */
Libevent里的数据结构应用
09-16
首先，我们要了解的是`queue.h`中的基本数据结构。Libevent主要使用链表和队列来管理事件和回调。其中，`EVLIST_HEAD()`定义了一个链表头，它是一个结构体，包含了链表的头节点和尾节点指针。`EVLIST_ENTRY()`则定义...
libevent中文word文档
07-28
在"一个小的异步IO例子"中，展示了如何使用LibEvent处理网络连接和数据传输。这部分还包含了Windows平台下的实现细节，以及对效率的讨论，解释了LibEvent如何有效地处理大量并发事件。 "正文前页"部分开始深入到...
libevent 参考手册中文版及源码解析
04-26
2. **事件结构**：Libevent的核心数据结构是event_base，它代表了一个事件循环。用户需要创建一个event_base实例，并在其上注册事件。 3. **事件类型**：Libevent支持四种基本事件类型：读事件、写事件、信号事件和...
LibEvent的说明帮助文档（中文）.zip
08-08
4. **事件类型**：LibEvent支持四种基本事件类型：读事件（data available for reading）、写事件（data can be written）、信号事件（信号发生）和定时事件（时间间隔到达）。 5. **定时器**：LibEvent提供了一个...
libevent源码分析
05-04
本文将对libevent源码进行分析，深入理解其实现原理以及关键的数据结构和函数接口。我们首先从libevent源码的整体架构开始，然后详细介绍一些重要的组件和它们的实现方式。 1. 开篇 在分析libevent源码之前，有必要...
libevent主要数据结构
spch2008的专栏
11-13 1040
1. 通用结构体 #define TAILQ_ENTRY(type) \ struct { \ struct type *tqe_next; /* next element */ \ struct type **tqe_prev; /* previous element */ \
libevent源码解析（一）核心数据结构
ty的博客
06-21 1157
一. 前言   Libevent是一个轻量级的开源高性能网络库，对于学习网络编程、学习C语言等都有着很大的帮助。Libevent 有几个显著的亮点：事件驱动（event-driven），高性能;轻量级，专注于网络，不如ACE那么臃肿庞大；源代码相当精炼、易读；跨平台，支持Windows、Linux、BSD和Mac Os；支持多种I/O多路复用技术， epoll、poll、dev/poll、sel...
libevent2.0源码学习二：通用数据结构
小豪之家
02-18 2108
本来想分析一下libevent实现的链表，队列，最小椎，哈希表这三个数据结构的，后来发现网上已经有人写过分析了，我就不重要造轮子啦。 上链接： 1：TAILQ队列(compat/sys/queue.h)：http://bachmozart.iteye.com/blog/292836 2：最小堆(minheap-internal.h)：http://www.cppblog.com/kevi
Libevent分解之数据结构- 字典表
星火的专栏
09-16 902
#ifndef _STUDENT_TEST_C_ #define  _STUDENT_TEST_C_ #include "queue.h" #define ev_uint8_t unsigned char #define ev_int8_t signed char struct StudentKV {     TAILQ_ENTRY(StudentKV) next;
(三)libevent源文件结构
Move_now的博客
08-26 910
前言在正式阅读源码之前,我们先对libevent的整体结构有大致的了解。这对我们在大体上了解libevent很有好处。源文件结构进入到libevent库目录里面一看,好像还挺多的,不过除去脚本还有.lo与.la这些用libtool编译出来的目标文件以及库文件,也没剩多少了。主要分为事件头文件、内部头文件、事件主框架、对多种多路I/O复用的机制的封装、信号管理方面、定时事件管理方面、缓冲区管理方面、日
libevent学习笔记五：libevent源代码文件组织结构
jyl_sh的专栏
05-02 1018
libevent学习笔记五：libevent源代码文件组织结构 1 ，前言 详细分析源代码之前，如果能对其代码文件的基本结构有个大概的认识和分类，对于代码的分析将是大有裨益的。本节内容不多，我想并不是说它不重要！ 2 ，源代码组织结构 Libevent的源代码虽然都在一层文件夹下面，但是其代码分类还是相当清晰的，主要可分为头文件、内部使用的头文件、辅助功能函数、日志、libevent框架、...
双链表（二）
jiangxt211的专栏
11-11 171
#ifndef _MY_HLIST_H #define _MY_HLIST_H typedef struct hlist_node { struct hlist_node *next; /* next element */ struct hlist_node **pprev; /* address of previous next element */ } HNODE; t...
静态内存分配-链表管理（1）单向量表讲解
yzau26的博客
07-30 1087
单向链表单向量表有头节点 和节点组成，头节点主要是管理链表使用，节点组成数据。数据结构 **last指向尾节点的Next指针，在节点尾部插入节点时，直接调整头节点的last内容的指向即可在尾部插入。first指针指向链表的首节点。 value是数据，Next指向下一个节点。链表操作链表成员变量定义成员变量主要有头结点和节点，头结点不是真正的有效数据，主要是利于链表的插入，遍历等，节点是链表中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

kgduu

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

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

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

打赏作者

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

抵扣说明：

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

余额充值