c语言实现 c++ list 非常方便于嵌入式stm32，具备foreach遍历功能，制定删除

已于 2022-08-23 17:00:08 修改
阅读量573 收藏
点赞数
分类专栏： stm32 文章标签： stm32 c语言 c++
于 2022-08-23 14:32:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ty21000/article/details/126484337
版权

一个头文件引入就可以，具备c++ foreach 遍历

list.h 头文件

#ifndef _LIST_H_
#define _LIST_H_
//编写链表 
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>

typedef void* (*_MallocType)(size_t);
typedef void (*_FreeType)(void*);


typedef struct _LIST_t
{
    void* _body;
    int   (*push_front)(struct _LIST_t* list, void* data, int len);
    int   (*push_back)(struct _LIST_t* list, void* data, int len);
    void* (*front)(struct _LIST_t* list);
    void* (*back)(struct _LIST_t* list);
    void  (*pop_front)(struct _LIST_t* list);
    void  (*pop_back)(struct _LIST_t* list);
    void  (*erase)(struct _LIST_t* list, void* data); // O(n)
    bool  (*empty)(struct _LIST_t* list);
    int   (*size)(struct _LIST_t* list);
    void  (*clear)(struct _LIST_t* list);
    void  (*foreach)(struct _LIST_t* list, void (*out_fn)(void* data));
    void  (*erase_cmp)(struct _LIST_t* list,void *del_data, bool (*cmp_fn)(void*, void*));
    void  (*destruct)(struct _LIST_t** list);
    void* (*foreach2)(struct _LIST_t* list, void* next);
}LIST_t;


static _MallocType list_malloc;
static _FreeType list_free;
/*
* @param max_num : 队列最大深度
* @param max_len : 队列最大宽度
* @param data_free : 用户自定义释放内存函数
*/
extern LIST_t* create_list(int max_num, int max_len, _MallocType fn_Malloc,_FreeType fn_Free,void (*data_free)(void*));







typedef struct _LINE_
{
    struct _LINE_* next;
    struct _LINE_* pre;
    void* data;
    uint32_t datalen;
}LINE_t;

typedef struct _BODY_
{
    LINE_t* _head;
    LINE_t* _tail;
    int _num;
    int _max_num;
    int _max_len;
    void (*_data_free)(void*);
}BODY_t;

static void _free_line_data(BODY_t* body, void* data)
{
    if(NULL == data)
        return;
    
    if(NULL != body->_data_free)
    {
            body->_data_free(data);
            return;
    }
    
    list_free(data);
}

static void _destruct(LIST_t** _list)
{
    if(NULL == _list) return;

    LIST_t* list = *_list;
    BODY_t* body = (BODY_t*)list->_body;
    list->clear(list);
    LINE_t* line = body->_head;
    if(NULL != list->_body)
    {
        list_free(list->_body);
        list->_body = NULL;
    }

    list_free(list);
    list = NULL;
}
/*
功能
清空 list 节点
参数
list：list指针
返回值 void
*/
static void _clear(LIST_t* list)
{
    BODY_t* body = (BODY_t*)list->_body;
    LINE_t* line = body->_head;
    while(line != NULL)
    {
        LINE_t* p = line->next;
        _free_line_data(body, line->data);
        list_free(line);
        line = p;
        body->_num--;
    }
    body->_head = NULL;
    body->_tail = NULL;
}
/*
功能
插入数据到 list 尾部
参数
list：list指针，data：插入数据指针，len：插入数据
返回值 int
0：成功， -1 ： 超过链表最大长度或者数据长度过长，-2：内存申请失败
*/
static int _push_back(LIST_t* list, void* data, int len)
{   
    BODY_t* body = (BODY_t*) list->_body;
    if(body->_num >= body->_max_num || len > body->_max_len)
        return -1;

    LINE_t* line = (LINE_t*) list_malloc(sizeof(LINE_t));
    if(NULL == line)
        return -2;

    memset(line, 0, sizeof(LINE_t));

    line->data = list_malloc(len);
    if(NULL == line->data)
    {
        list_free(line);
        return -2;
    }
    memset(line->data, 0, len);
    memcpy(line->data, data, len);
    line->datalen = len;

    body->_num ++;

    if(NULL == body->_head) // 这里认为初始化, 头尾都指向同个结构
    {
        body->_head = line;
        body->_tail = line;
        return 0;
    }

    line->pre = body->_tail;
    body->_tail->next = line;
    body->_tail = line;

    return 0;
}
/*
功能
插入数据到 list 头部
参数
list：list指针，data：插入数据指针，len：插入数据
返回值 int
0：成功， -1 ： 超过链表最大长度或者数据长度过长，-2：内存申请失败
*/
static int _push_front(LIST_t* list, void* data, int len)
{   
    BODY_t* body = (BODY_t*) list->_body;
    if(body->_num + 1 >= body->_max_num || len > body->_max_len)
        return -1;

    LINE_t* line = (LINE_t*) list_malloc(sizeof(LINE_t));
    if(NULL == line)
        return -2;

    memset(line, 0, sizeof(LINE_t));

    line->data = list_malloc(len);
    if(NULL == line->data)
    {
        list_free(line);
        return -2;
    }
    memset(line->data, 0, len);
    memcpy(line->data, data, len);
    line->datalen = len;

    body->_num ++;

    if(NULL == body->_head) // 这里认为初始化, 头尾都指向同个结构
    {
        body->_head = line;
        body->_tail = line;
        return 0;
    }

    line->next = body->_head;
    body->_head->pre = line;
    body->_head = line;

    return 0;
}
/*
功能
获取 list 头部数据
参数
list：list指针
返回值 void*
NULL：失败或者list头为空， 其他 ： list头部数据
*/
static void* _front(LIST_t* list)
{
    BODY_t* body = (BODY_t*)list->_body;
    if(NULL == body)
        return NULL;
    
    return body->_head->data;
}
/*
功能
获取 list 尾部数据
参数
list：list 指针
返回值 void*
NULL：失败或者list尾为空， 其他 ： list尾部数据
*/
static void* _back(LIST_t* list)
{
    BODY_t* body = (BODY_t*)list->_body;
    if(NULL == body)
        return NULL;

    return body->_tail->data;    
}

// 轮询删除, 正常不建议使用 O(n), data 是链表中的指针
static void _erase(LIST_t* list, void* data)
{
    BODY_t* body = (BODY_t*)list->_body;
    LINE_t* line = body->_head;
    while(line)
    {
        if(line->data == data)
        {
            LINE_t* p = line;
            if(NULL != p->pre)
                p->pre->next = p->next;
        
            if(NULL != p->next)
                p->next->pre = p->pre;
            
            if(body->_head == p)
            {
                body->_head = p->next;
            }
            if(body->_tail == p)
            {
                body->_tail = p->pre;
            }
            body->_num--;

            _free_line_data(body, line->data);
            list_free(line);
            break;
        }
        line = line->next;
    }
}

//删除由外部比较返回true的节点，删除后立即结束遍历
static void _erase_cmp(LIST_t* list, void* del_data, bool (*cmp_fn)(void*, void*))
{
	BODY_t* body = (BODY_t*)list->_body;
	LINE_t* line = body->_head;
	while (line)
	{
		if (cmp_fn(line->data,del_data))
		{
			LINE_t* p = line;
			if (NULL != p->pre)
				p->pre->next = p->next;

			if (NULL != p->next)
				p->next->pre = p->pre;

			if (body->_head == p)
			{
				body->_head = p->next;
			}
			if (body->_tail == p)
			{
				body->_tail = p->pre;
			}
			body->_num--;

			_free_line_data(body, line->data);
			list_free(line);
			break;
		}
		line = line->next;
	}
}
//正向遍历
static void _foreach(LIST_t* list, void (*out_fn)(void* data))
{
	BODY_t* body = (BODY_t*)list->_body;
	LINE_t* line = body->_head;
	while (line)
	{
        out_fn(line->data);
		line = line->next;
	}
}
//返回指针式的遍历
static void* _foreach2(LIST_t* list, void* next)
{
	BODY_t* body = NULL;
	LINE_t* line = NULL;
	if (next==NULL)
	{
		body = (BODY_t*)list->_body;
		line = body->_head;
	}
	else
	{
		line = (LINE_t*)next;
	}
	if (line)
	{

		line = line->next;
	}
	return (void*)line;
}
/*
功能
删除 list 头部节点
参数
list：list指针
返回值 void
*/
static void _pop_front(LIST_t* list)
{
    BODY_t* body = (BODY_t*)list->_body;
    LINE_t* line = body->_head;
    if(NULL == line)
        return;

    body->_head = line->next;

    if(NULL != body->_head)
        body->_head->pre = NULL;

    if(line == body->_tail)
        body->_tail = NULL;
    
    _free_line_data(body, line->data);
    list_free(line);

    body->_num--;
}
/*
功能
删除 list 尾部节点
参数
list：list指针
返回值 void
*/
static void _pop_back(LIST_t* list)
{
    BODY_t* body = (BODY_t*)list->_body;
    LINE_t* line = body->_tail;
    if(NULL == line)
        return;
    
    body->_tail = line->pre;

    if(NULL != body->_tail)
        body->_tail->next = NULL;

    if(line == body->_head)
        body->_head = NULL;

    _free_line_data(body, line->data);
    list_free(line);

    body->_num--;
}
/*
* 功能
list 是否为空
参数
list：list指针
返回值 bool
true：list为空，false：list不为空
*/
static bool _empty(LIST_t* list)
{
    BODY_t* body = (BODY_t*)list->_body;
    return (body->_tail == NULL);
}
/*
* 功能
获取 list 节点数量
参数
list：list指针
返回值 int
list 节点数量
*/
static int _size(LIST_t* list)
{
    BODY_t* body = (BODY_t*)list->_body;
    return body->_num;
}

static int _construct(LIST_t* list, int max_num, int max_len,void (*data_free)(void*)) // 调用前要确定 list 已经分配内存
{
	
    list->_body = list_malloc(sizeof(BODY_t));
    if(NULL == list->_body)
        return -1;
    memset(list->_body, 0, sizeof(BODY_t));
    BODY_t* body = (BODY_t*)list->_body;
    body->_max_num = max_num;
    body->_max_len = max_len;
    body->_data_free = data_free;
    
    list->push_back = _push_back;
    list->push_front = _push_front;
    list->front = _front;
    list->back = _back;
    list->pop_front = _pop_front;
    list->pop_back = _pop_back;
    list->erase = _erase;
    list->empty = _empty;
    list->size = _size;
    list->clear = _clear;
    list->destruct = _destruct;
    list->foreach = _foreach;
    list->erase_cmp = _erase_cmp;
    list->foreach2 = _foreach2;

    return 0;
}

LIST_t* create_list(int max_num, int max_len, _MallocType fn_Malloc,_FreeType fn_Free,void (*data_free)(void*))
{
	list_malloc = fn_Malloc;
	list_free = fn_Free;
    LIST_t* list =  (LIST_t*)list_malloc(sizeof(LIST_t));
    if(NULL == list)
        return NULL;
    memset(list, 0, sizeof(LIST_t));
    if( _construct(list, max_num, max_len, data_free)!= 0)
    {
        list_free(list);
        return NULL;
    }

    return list;
}



#endif

调用测试


#include "windows.h"
#include <iostream>
#include <stdio.h>
#include "list.h"

typedef struct _DATA_
{
	int len;
	char buff[];
} DATA_t;

void free_data(void* _data)
{
	DATA_t* data = (DATA_t*)_data;
	if (NULL == data)
		return;
	free(data);
}
void for_eacth_list(void *data) {
	DATA_t* it = (DATA_t*)data;
	if (NULL == it)
	{
		printf("Get front error\n");
		exit(-1);
	}
	printf("len:%d, buff:%.*s\n", it->len, it->len, it->buff);


}
bool dele_list(void* out_data, void* del_data) {
	DATA_t* it = (DATA_t*)out_data;
	DATA_t* del_datait = (DATA_t*)del_data;
	if (NULL == it|| del_data==NULL)
	{
		printf("Get front error\n");
		return false;
	}
	//printf("len:%d, buff:%.*s\n", it->len, it->len, it->buff);
	if (strcmp(it->buff, del_datait->buff)==0)
	{
		return true;
	}
	else
	{
		return false;
	}


}
void test_list(void) {
	int ccc = 10;
	for (int j=0;j<ccc;j++)
	{
		LIST_t* list = create_list(ccc, 100, malloc, free, free_data);
		if (NULL == list)
		{
			printf("Create list error\n");
			exit(-1);
		}
		for (int i = 0; i < ccc; i++)
		{
			char* num_str = (char*)malloc(99);
			sprintf(num_str, "%d", i);
			if (num_str == NULL)
			{
				printf("Create num error\n");
				exit(-1);
			}

			DATA_t* data = (DATA_t*)malloc(sizeof(DATA_t) + strlen(num_str) * sizeof(char) + 1);
			if (NULL == data)
			{
				printf("Create data error\n");
				exit(-1);
			}
			memset(data, 0, sizeof(DATA_t) + strlen(num_str) * sizeof(char) + 1);
			data->len = strlen(num_str);
			strcpy(data->buff, num_str);
			int err = list->push_back(list, data, sizeof(DATA_t) + data->len * sizeof(char) + 1);
			if (err < 0)
				printf("push back error, errcode:%d", err);

			free(num_str);
			free(data);
		}

		printf("list size:%d\n", list->size(list));
		
		list->foreach(list, for_eacth_list);
		//删除999字符串
		DATA_t* data = (DATA_t*)malloc(sizeof(DATA_t) + 100 * sizeof(char) + 1);
		if (NULL == data)
		{
			printf("Create data error\n");
			exit(-1);
		}
		memset(data, 0, sizeof(DATA_t) + 100* sizeof(char) + 1);
		data->len = 100;
		strcpy(data->buff, "9");
		list->erase_cmp(list,data, dele_list);
		/*LINE_t* itr = NULL;
		itr = (LINE_t*)list->foreach2(list, itr);
		while (itr)
		{
			DATA_t* it = (DATA_t*)itr->data;
			printf("len:%d, buff:%.*s\n", it->len, it->len, it->buff);
			itr = (LINE_t*)list->foreach2(list, itr);
		}*/
		for (LINE_t* itr = (LINE_t*)list->foreach2(list, NULL);itr; itr = (LINE_t*)list->foreach2(list, itr))
		{
			DATA_t* it = (DATA_t*)itr->data;
			printf("len:%d, buff:%.*s\n", it->len, it->len, it->buff);
		}
		//list->clear(list);
		printf("clear list size:%d\n", list->size(list));
		while (!list->empty(list))
		{
			DATA_t* it = (DATA_t*)list->front(list);
			if (NULL == it)
			{
				printf("Get front error\n");
				exit(-1);
			}
			printf("len:%d, buff:%.*s\n", it->len, it->len, it->buff);

			list->pop_front(list);
		}
		printf("list size:%d\n", list->size(list));
		list->clear(list);
		printf("list size:%d\n", list->size(list));
		list->destruct(&list);
	}
	

}

int main()
{
	test_list();

	int c = getchar();

}
mokersii
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#使用yield关键字让自定义集合实现foreach遍历的方法
09-04
通过这种方式，`yield`关键字使得自定义集合在不实现`IEnumerable`接口的情况下，依然能够方便地进行`foreach`遍历。 总的来说，`yield`关键字提供了一种高效且简洁的方式，使得自定义集合类可以轻松支持`foreach`...
PHP foreach遍历多维数组实现方式
10-21
主要为大家详细介绍了PHP foreach遍历多维数组实现方式,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++学习笔记——（八）map容器、for_each、预定义函数
miyuexingchen的专栏
11-27 2701
注：编码工具是CLion+Cygwin64 目录 map multimap for_each 对象存入后和从容器中取出的细节 预定义函数 map map会对key进行排序。 #include <iostream> using namespace std; // 先导入头文件 #include <map> int main(){ map<int, string> m; // map的集中插入元素的方式 m...
c语言List头文件和应用
superbfly的专栏
11-29 1万+
util_list.h #ifndef __UTIL_LIST__ #define __UTIL_LIST__ /*双链节点*/ typedef struct list_node { list_node * prev; list_node * next; } LIST_NODE; /*单链节点*/ typedef struct slist_node { slist_node * ne
c语言list头文件,关于调用头文件list.h
weixin_29570673的博客
05-24 557
该楼层疑似违规已被系统折叠隐藏此楼查看此楼诸如此类的，反馈了一大堆的头文件问题，无法把所有的代码上传，刚才代码全部被度娘吃了d:\vc98\include\list.h(38) : error C2059: syntax error : '}'d:\vc98\include\list.h(40) : error C2143: syntax error : missing '{' before '...
【C标准头文件】＜stdio.h＞
麦芽的博客
02-05 257
C语言标准输入输出头文件
87 C++ - 常用遍历算法
阿甘兄
10-09 417
/* 遍历算法 遍历容器元素 @param beg 开始迭代器 @param end 结束迭代器 @param _callback 函数回调或者函数对象 @return 函数对象 */ for_each(iterator beg, iterator end, _callback); /* transform算法 将指定容器区间元素搬运到另一容器中 注意 : transform...
C#在foreach遍历删除集合中元素的三种实现方法
08-25
C#在foreach遍历删除集合中元素的三种实现方法 C#中，foreach遍历删除集合中元素是很常见的操作，但是删除元素时，集合的大小和元素索引值会发生变化，从而导致在foreach中删除元素时会抛出异常。下面我们将介绍三...
基于STM32的FreeRTOS学习之列表和列表项（九）
Leisure_ksj的博客
03-20 490
记录一下，方便以后翻阅~ 列表和列表项是FreeRTOS的一个数据结构，FreeRTOS大量使用列表和列表项，它是FreeRTOS的基石。 1. 什么是列表和列表项 1.1 列表 列表是FreeRTOS的一个数据结构，被用来跟踪FreeRTOS中的任务。与列表有关的东西都在list.c和list.h文件里。在list.h中定义了一个List_t的结构体： typedef struct xLIST { listFIRST_LIST_INTEGRITY_CHECK_VALUE // 检查列表完整性，将c
List中的三种循环遍历及删除操作
shinian_77的博客
04-01 9456
1、for循环遍历list public static void main(String[] args) { List list = new ArrayList(); list.add("asdf"); list.add("我多想"); list.add("我多想"); list.add("一少年"); list.add(1); System.out.println(list);
C 语言常用库分类
weixin_59246157的博客
04-17 1885
stdlib.h：提供内存分配和释放函数，如 `malloc()` 和 `free()`。- sys/socket.h：提供套接字函数，如 `socket()` 和 `bind()`。- stdio.h：提供输入和输出函数，如 `printf()` 和 `scanf()`。- signal.h：提供处理信号的函数，如 `signal()` 和 `kill()`。- math.h：提供数学函数，如 `sin()` 和 `sqrt()`。- SDL：提供跨平台的 2D 图形渲染和输入处理库。
链表在STM32中的应用
人生一路，点滴记录
12-11 1万+
目录 1、为何引入链表 2、链表实现 3、测试函数 、为何引入链表 在程序中经常面临一个问题，我们需要保存一定数量的对象，但是对象数目是不确定的，或者说是随时增加或减少的。这时候最简单的方法是创建一个足够大的数组，用来存储这些对象。我最近开发一个项目就遇到类似的问题，下面我把问题简化一下。 需求：通过PC下发一些矩形的坐标和宽高信息，每个区域有个ID编号，并在这些矩形内填充一定的数据。 通常情况下，最简单易懂的做法是，限制最多5个区域，每个区域存储1K数据。因此设置了这样的一个结构体（类似于面
C++中的foreach用法
热门推荐
leyou2018 的博客
01-18 8万+
在c++中，一般人只知道foreach分开写为“for each”时的用法，却不知道“foreach”的用法。不多说，直接上代码。QStringList listTemp; QString strTemp1; QString strTemp2; tempList.append("aaa"); tempList.append("bbb"); tempList.ap
c++ 学习点滴 list forEach
hurry07
08-15 238
又经过一个周的实战, 我的c++水平已经能够区分 :: . -> 了, 弱爆了的说 :D 下面分享下我的list学习经验, 直接上代码. 由于c++还数量所有 toString 方法有点恶心, 欢迎指导. [code="c++"] /* * CharacterColl.h * * Created on: 2012-8-14 * Author: jie ...
在C++中实现foreach循环，比for_each更简洁！
Rainloving的专栏
07-23 9769
原文：http://blogread.cn/it/article/2570?f=sr python,c#,java里面都有类似于foreach的结构，stl里面虽然有for_each这个函数，但是感觉使用还是太繁琐了一些，所以就自己实现了一个。 先来看看stl里面的for_each函数，官方文档上的原型如下： 1 Function for_each (Inp
C++11 for循环新用法、for_each 用法
补丁_1024的博客
12-10 1万+
c++11 for循环多了新的语法#include<iostream> #include<algorithm> #include<vector> using namespace std;int main() { vector<int> vec; for(int i=0;i<10;++i) { vec.push_back(i); } for(int
STM32 学习之不定长数组的定义
繁夜
12-17 9178
通常情况下，keil、IAR 在定义数组的时候，都是需要指定数组的长度，但是我们大多数情况下是不知道我们输入的数据可能会有多长。 所以为了尽可能的包含所有的情况，通常的做法就是在定义数组的时候，将数组的长度定义的非常长。结果就会导致多数情况下，大量的内存空间被浪费了。 其实在C99新增的标准中是有关于这个的定义的，而且Keil和IAR 也是支持的。 下面我们来看看具体的实现方法： 一、在Keil ...
list,each联用遍历数组
俗人世界
01-06 1322
目录 一: list函数 二: each函数 三: list 和each 配合 一: list函数 1.语法: list ( mixed $变量1 [, mixed $变量n ] ) 请注意：索引数组的一一对应原则,list第一个变量对应的是下标为0的数组元素,下标为1的对应的是list里面的第二个数组元素; 2.功能:  将索引数组下标为0的对应我变量1，下标1的对应变量2，...
foreach遍历list集合删除
最新发布
07-28
使用foreach循环遍历list集合并删除元素的方法如下： ```java List<String> list = new ArrayList<>(); list.add("stu1"); list.add("stu2"); list.add("stu3"); list.add("stu4"); Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String item = iterator.next(); if (item.equals("stu2")) { iterator.remove(); } } System.out.println(list); ``` 在这个例子中，我们首先创建了一个ArrayList集合，并向其中添加了一些元素。然后，我们使用Iterator迭代器来遍历集合中的元素。在遍历过程中，我们使用if语句来判断当前元素是否需要删除，如果需要删除，则使用Iterator的remove()方法来删除该元素。最后，我们打印出删除元素后的集合内容。 请注意，使用foreach循环遍历集合时，不能直接在循环中删除元素，因为这会导致ConcurrentModificationException异常。因此，我们需要使用Iterator来进行安全的删除操作。 #### 引用[.reference_title] - *1* [foreach遍历集合](https://blog.csdn.net/m0_53821599/article/details/119655736)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [mybatis使用foreach遍历list集合或者array数组方式](https://blog.csdn.net/weixin_43982687/article/details/126475109)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值