4_13_GLib库入门与实践_数据列表

最新推荐文章于 2022-03-13 00:15:22 发布
最新推荐文章于 2022-03-13 00:15:22 发布
阅读量320 收藏 1
点赞数
分类专栏： GLib库入门与实践 文章标签： 数据结构 GLib c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/field1003/article/details/123436012
版权

简介

（本段内容翻译自官方文档）
数据列表提供任意数据元素的列表，可以使用字符串或与字符串的GQuark访问这些数据元素。
GQuark方法更快，因为无论如何都必须将字符串转换为 GQuarks。

  • 数据列表用于将任意数据与 GObject 相关联，使用 g_object_set_data()和相关函数。
  • 要创建数据列表，请使用 g_datalist_init()。
  • 要将数据元素添加到数据列表，请使用 g_datalist_id_set_data()、g_datalist_id_set_data_full()、g_datalist_set_data() 和 g_datalist_set_data_full()。
  • 要从数据列表中获取数据元素，请使用 g_datalist_id_get_data()和g_datalist_get_data()。
  • 要遍历数据列表中的所有数据元素，请使用 g_datalist_foreach()（非线程安全）。
  • 要从数据列表中删除数据元素，请使用 g_datalist_id_remove_data()和g_datalist_remove_data()。
  • 要从数据列表中删除所有数据元素，请使用 g_datalist_clear()。

数据结构

GData是一个不透明的数据结构。

typedef struct _GData GData;

函数列表

void 	g_datalist_init ()
#define 	g_datalist_id_set_data()
void 	g_datalist_id_set_data_full ()
gpointer 	g_datalist_id_get_data ()
#define 	g_datalist_id_remove_data()
gpointer 	g_datalist_id_remove_no_notify ()
gpointer 	(*GDuplicateFunc) ()
gpointer 	g_datalist_id_dup_data ()
gboolean 	g_datalist_id_replace_data ()
#define 	g_datalist_set_data()
#define 	g_datalist_set_data_full()
gpointer 	g_datalist_get_data ()
#define 	g_datalist_remove_data()
#define 	g_datalist_remove_no_notify()
void 	g_datalist_foreach ()
void 	g_datalist_clear ()
void 	g_datalist_set_flags ()
void 	g_datalist_unset_flags ()
guint 	g_datalist_get_flags ()

函数功能分类

整体上来讲，数据列表可以分为两大类：

  • g_data_list_id_xxx：将一个GQuark与一个任意元素数据相关联的一组操作函数
  • g_data_list_xxx：是将一个字符串与一个任意元素数据相关联的一组操作函数

函数功能说明及综合演示

初始化

将datalist初始化为空，如果该datalist有指向堆上的内存，初始化前需要先释放该内存以避免内存泄露。

g_datalist_init ()
插入

带full的函数，可以自定义元素的释放函数。
注意：插入的数据不会被复制，因此局部变量、函数结束被自动释放的变量不可插入到数据列表。
如果插入的key已经存在，且存在元素自定义释放函数，该key对应的元素会被释放函数释放，新的元素将被插入。

g_datalist_id_set_data()
g_datalist_id_set_data_full ()

下面演示插入两种不同的数据，一种是固定长度的结构体（内部无指针），一种是非固定长度的结构体（内部有指针）。

固定长度结构体插入
示例代码如下：
源码见glib_examples\glib_datalist\glib_datalist_struct_no_pointer

#include <glib.h>

typedef struct my_data_tag {
    gint x;
    gint y;
}my_data_t;

static void g_datalist_id_test (void)
{
    GData *list = NULL;
    my_data_t *data1 = NULL;
    my_data_t *data2 = NULL;
    my_data_t *data3 = NULL;
    my_data_t *ret = NULL;

    g_datalist_init (&list);

    data1 = g_new0(my_data_t, 1);
    data1->x = 101;
    data1->y = 201;
    data2 = g_new0(my_data_t, 1);
    data2->x = 102;
    data2->y = 202;
    data3 = g_new0(my_data_t, 1);
    data3->x = 103;
    data3->y = 203;

    g_print("data1->x(%p): %d, data1->y(%p):%d \n", &data1->x, data1->x, &data1->y, data1->y);

    g_datalist_id_set_data (&list, g_quark_from_string ("one"), data1);
    g_datalist_id_set_data (&list, g_quark_from_string ("two"), data2);
    g_datalist_id_set_data (&list, g_quark_from_string ("three"), data3);

    ret = g_datalist_id_get_data (&list, g_quark_from_string ("one"));
    g_print("ret->x(%p): %d, ret->y(%p):%d \n", &ret->x, ret->x, &ret->y, ret->y);

    g_free(data1);
    g_free(data2);
    g_free(data3);
    g_datalist_clear (&list);
}

int main (int argc, char** argv)
{
    g_datalist_id_test();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_datalist_struct_no_pointer
data1->x(0x2193dc0): 101, data1->y(0x2193dc4):201
ret->x(0x2193dc0): 101, ret->y(0x2193dc4):201

非固定长度结构体插入
示例代码如下：
源码见glib_examples\glib_datalist\glib_datalist_struct_with_pointer

#include <glib.h>

typedef struct my_data_tag {
    gint id;
    gchar *name;
}my_data_t;

static void _datalist_id_destroy_func(gpointer data)
{
    my_data_t *p = (my_data_t *)data;
    if(NULL == p) {
        return;
    }

    g_print("destroy %s! \n", p->name);

    g_free(p->name);
    g_free(p);
}

static void g_datalist_id_test (void)
{
    GData *list = NULL;
    my_data_t *data1 = NULL;
    my_data_t *data2 = NULL;
    my_data_t *data3 = NULL;
    my_data_t *ret = NULL;

    g_datalist_init (&list);

    data1 = g_new0(my_data_t, 1);
    data1->id = 100;
    data1->name = g_strdup_printf("name:%d", data1->id);
    data2 = g_new0(my_data_t, 1);
    data2->id = 101;
    data2->name = g_strdup_printf("name:%d", data2->id);
    data3 = g_new0(my_data_t, 1);
    data3->id = 102;
    data3->name = g_strdup_printf("name:%d", data3->id);

    g_print("data1->id(%p): %d \n", &data1->id, data1->id);
    g_print("data1->name(%p): %s \n", data1->name, data1->name);

    g_datalist_id_set_data_full(&list, g_quark_from_string ("one"), data1, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("two"), data2, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("three"), data3, _datalist_id_destroy_func);

    ret = g_datalist_id_get_data (&list, g_quark_from_string ("one"));

    g_print("ret->id(%p): %d \n", &ret->id, ret->id);
    g_print("ret->name(%p): %s \n", ret->name, ret->name);

    g_datalist_clear (&list);
}

int main (int argc, char** argv)
{
    g_datalist_id_test();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_datalist_struct_with_pointer/glib_datalist_struct_with_pointer
data1->id(0x13eadc0): 100
data1->name(0x13eae50): name:100
ret->id(0x13eadc0): 100
ret->name(0x13eae50): name:100
destroy name:100!
destroy name:101!
destroy name:102!

下面演示一下g_datalist_id_set_data_full函数替换数据列表中已有数据的情况。
示例代码如下：
源码见glib_examples\glib_datalist\glib_datalist_set_data_full

#include <glib.h>

typedef struct my_data_tag {
    gint id;
    gchar *name;
}my_data_t;

static void _datalist_id_destroy_func(gpointer data)
{
    my_data_t *p = (my_data_t *)data;
    if(NULL == p) {
        return;
    }

    g_print("destroy %s! \n", p->name);

    g_free(p->name);
    g_free(p);
}

static void g_datalist_id_test (void)
{
    GData *list = NULL;
    my_data_t *data1 = NULL;
    my_data_t *data2 = NULL;
    my_data_t *data3 = NULL;
    my_data_t *data4 = NULL;
    my_data_t *ret = NULL;

    g_datalist_init (&list);

    data1 = g_new0(my_data_t, 1);
    data1->id = 101;
    data1->name = g_strdup_printf("name:%d", data1->id);
    data2 = g_new0(my_data_t, 1);
    data2->id = 102;
    data2->name = g_strdup_printf("name:%d", data2->id);
    data3 = g_new0(my_data_t, 1);
    data3->id = 103;
    data3->name = g_strdup_printf("name:%d", data3->id);
    data4 = g_new0(my_data_t, 1);
    data4->id = 104;
    data4->name = g_strdup_printf("name:%d", data4->id);

    g_print("data2->id(%p): %d \n", &data2->id, data2->id);
    g_print("data2->name(%p): %s \n", data2->name, data2->name);

    g_datalist_id_set_data_full(&list, g_quark_from_string ("one"), data1, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("two"), data2, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("three"), data3, _datalist_id_destroy_func);

    g_print("before set_data_full: two \n");
    g_datalist_id_set_data_full(&list, g_quark_from_string ("two"), data4, _datalist_id_destroy_func);
    g_print("after set_data_full: two \n");

    ret = g_datalist_id_get_data (&list, g_quark_from_string ("two"));

    g_print("ret->id(%p): %d \n", &ret->id, ret->id);
    g_print("ret->name(%p): %s \n", ret->name, ret->name);

    g_datalist_clear (&list);
}

int main (int argc, char** argv)
{
    g_datalist_id_test();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_datalist_set_data_full
data2->id(0x610e70): 102
data2->name(0x610e90): name:102
before set_data_full: two
destroy name:102!
after set_data_full: two
ret->id(0x610ef0): 104
ret->name(0x610f10): name:104
destroy name:101!
destroy name:104!
destroy name:103!
获取
// 获取元素的一份拷贝而不是元素本身
g_datalist_id_get_data
// 本函数内部加锁，当获取元素数据时，其他函数不可修改其值，因此是线程安全的。
g_datalist_id_dup_data
替换
// 替换数据列表中的元素。
g_datalist_id_replace_data

示例代码如下：
源码见glib_examples\glib_datalist\glib_datalist_replace

#include <glib.h>

typedef struct my_data_tag {
    gint id;
    gchar *name;
}my_data_t;

static void _datalist_new_id_destroy_func(gpointer data)
{
    my_data_t *p = (my_data_t *)data;
    if(NULL == p) {
        return;
    }

    g_print("new destroy %d! \n", p->id);

    g_free(p);
}

static void _datalist_id_destroy_func(gpointer data)
{
    my_data_t *p = (my_data_t *)data;
    if(NULL == p) {
        return;
    }

    g_print("destroy %s! \n", p->name);

    g_free(p->name);
    g_free(p);
}

static void g_datalist_id_test (void)
{
    GData *list = NULL;
    my_data_t *data1 = NULL;
    my_data_t *data2 = NULL;
    my_data_t *data3 = NULL;
    my_data_t *data4 = NULL;
    my_data_t *old_data = NULL;
    my_data_t *ret = NULL;
    GDestroyNotify old_destroy;

    g_datalist_init (&list);

    data1 = g_new0(my_data_t, 1);
    data1->id = 101;
    data1->name = g_strdup_printf("name:%d", data1->id);
    data2 = g_new0(my_data_t, 1);
    data2->id = 102;
    data2->name = g_strdup_printf("name:%d", data2->id);
    data3 = g_new0(my_data_t, 1);
    data3->id = 103;
    data3->name = g_strdup_printf("name:%d", data3->id);
    data4 = g_new0(my_data_t, 1);
    data4->id = 104;
    //data4->name = g_strdup_printf("name:%d", data4->id);

    g_print("data2->id(%p): %d \n", &data2->id, data2->id);
    g_print("data2->name(%p): %s \n", data2->name, data2->name);

    g_datalist_id_set_data_full(&list, g_quark_from_string ("one"), data1, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("two"), data2, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("three"), data3, _datalist_id_destroy_func);

    old_data = g_datalist_id_get_data(&list, g_quark_from_string ("two"));
    if(NULL == old_data) {
        g_print("can't find key: two \n");
        g_datalist_clear(&list);
        return;
    }
    g_print("before set_data_full: two \n");
    g_datalist_id_replace_data(&list, g_quark_from_string ("two"), old_data, data4, _datalist_new_id_destroy_func, &old_destroy);
    if(NULL != old_destroy) {
        old_destroy(data2);
    }
    g_print("after set_data_full: two \n");

    ret = g_datalist_id_get_data (&list, g_quark_from_string ("two"));

    g_print("ret->id(%p): %d \n", &ret->id, ret->id);
    //g_print("ret->name(%p): %s \n", ret->name, ret->name);

    g_datalist_clear (&list);
}

int main (int argc, char** argv)
{
    g_datalist_id_test();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_datalist_replace
data2->id(0x23b4e70): 102
data2->name(0x23b4e90): name:102
before set_data_full: two
destroy name:102!
after set_data_full: two
ret->id(0x23b4ef0): 104
destroy name:101!
new destroy 104!
destroy name:103!

上述示例程序有三个需要注意的地方：

  1. old_data必须是已经存在于列表中的一个元素，手动构造出的，即使值完全一致，也不可以。
  2. 被替换的元素不会被自动释放，需要手动调用其释放函数。
  3. 新插入的元素，自带一个释放函数，可以和之前的释放函数不一样。列表清空或销毁时，会自动调用对应的元素释放函数。
    一般来说，数组，链表，队列，hash，树，其每个节点的类型都是相同的，但我们可以使用g_datalist_id_replace_data构造一个数据元素类型不同的数据列表。
    举例：数据列表有ABCD四个类型为char *的元素，E为一个结构体，可以通过本函数替代C，得到ABED数据列表，其中ABD为char*型元素，E为结构体元素。

g_datalist_xxx没有replace函数，因此每个元素的类型都是相同的，可以使用提供的foreach对元素进行遍历。

删除
// 删除元素，元素释放函数会被自动调用
g_datalist_id_remove_data()
// 删除元素，元素释放函数不会被自动调用，用户需手动释放内存
g_datalist_id_remove_no_notify ()

示例代码如下：
源码见glib_examples\glib_datalist\glib_datalist_delete

#include <glib.h>

typedef struct my_data_tag {
    gint id;
    gchar *name;
}my_data_t;

static void _datalist_id_destroy_func(gpointer data)
{
    my_data_t *p = (my_data_t *)data;
    if(NULL == p) {
        return;
    }

    g_print("destroy %s! \n", p->name);

    g_free(p->name);
    g_free(p);
}

static void g_datalist_id_test (void)
{
    GData *list = NULL;
    my_data_t *data1 = NULL;
    my_data_t *data2 = NULL;
    my_data_t *data3 = NULL;
    my_data_t *data4 = NULL;
    my_data_t *del_data = NULL;
    my_data_t *ret = NULL;

    g_datalist_init (&list);

    data1 = g_new0(my_data_t, 1);
    data1->id = 101;
    data1->name = g_strdup_printf("name:%d", data1->id);
    data2 = g_new0(my_data_t, 1);
    data2->id = 102;
    data2->name = g_strdup_printf("name:%d", data2->id);
    data3 = g_new0(my_data_t, 1);
    data3->id = 103;
    data3->name = g_strdup_printf("name:%d", data3->id);
    data4 = g_new0(my_data_t, 1);
    data4->id = 104;
    data4->name = g_strdup_printf("name:%d", data4->id);

    g_datalist_id_set_data_full(&list, g_quark_from_string ("one"), data1, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("two"), data2, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("three"), data3, _datalist_id_destroy_func);
    g_datalist_id_set_data_full(&list, g_quark_from_string ("four"), data4, _datalist_id_destroy_func);

    g_datalist_remove_data(&list, "two");

    del_data = g_datalist_remove_no_notify(&list, "three");
    g_print("del_data->id: %d, del_data->name: %s \n", del_data->id, del_data->name);
    _datalist_id_destroy_func(del_data);

    g_print("clear datalist \n");
    g_datalist_clear (&list);
}

int main (int argc, char** argv)
{
    g_datalist_id_test();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_datalist_delete
destroy name:102!
del_data->id: 103, del_data->name: name:103
destroy name:103!
clear datalist
destroy name:101!
destroy name:104!
数据列表标志

不使用额外空间的情况下即可保存数据列表的标志值。除非运行环境的内存空间非常小，否则一般不会用到。GObject用了这个特性。

g_datalist_set_flags 
g_datalist_unset_flags 
g_datalist_get_flags
field1003
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
glib-html-2.6.6.tar.gz_glib_glib-2.6.6.tar.b_linux gl
09-22
glid编写实例，glid应用，可供参考。
message_pump_glib.rar_On Message
09-24
A brief refresher on GLib: Source Code for Linux.
buffered_file.rar_glib
09-24
GLib testing framework examples and tests.
WDTandEINT.rar_glib.h 2410
09-14
三星ARM2410的看门狗与中断结合实验
U8glib_forwardveg_U8glib\utility_u8glib支持oled_u8glib_u8glib库下载_源
10-03
u8glib库支持多种oled显示驱动，功能强大
glib中的GList ,GSList,GString,GTree,GTimer
WhoisPo的专栏
04-15 5446
Glib数据结构 Glib数据结构表 GList 最初都是NULL，不断插入形成表name=g_list_append(name,datapointer)  //注意这里并不是拷贝name=g_list_prepend(name,datapointer);name=g_list_insert(name,dattapointer,pos); //位置是从0开始在表中移动name=g_list_next(name)name=g_list_previous(name；name=g_list_last(name);
glib库双向链表GList介绍
plusboy的专栏
01-21 1万+
在上一篇文章里我介绍了glib库中单向链表的用法，这篇文章介绍glib库双向链表的用法，还是沿用上一篇文章的风格，采用在代码中加入注释来说明代码，最后贴出程序的运行结果，然后加以少量说明。双向链表与单向链表的区别是，从一个节点，不仅能访问到它的下一个节点，还能访问到它的上一个节点，其定义如下：struct GList{ gpointer data;   GList *next;   
4_14_GLib库入门与实践_数据集
field1003的博客
03-13 264
简介 （本段内容翻译自官方文档） 数据集将数据元素组与特定的内存位置相关联。如果您需要将数据与从外部库返回的结构相关联，这些非常有用。由于您无法修改结构，因此您可以将其在内存中的位置用作数据集的键，您可以在其中将任意数量的数据元素与其关联。 大多数数据集函数有两种形式。第一种形式使用字符串来标识与位置关联的数据元素。第二种形式使用 GQuark 标识符，这些标识符是通过调用g_quark_from_string()或g_quark_from_static_string()创建的。第二种形式更快，因为它不需要
glib中g_object_set_data及相关函数的使用［0713］
weixin_30569153的博客
07-13 489
主要使用的函数有g_object_set_data与g_object_get_data两个函数他们的主要功能是把某个指针（任意类型的［可以指向某个构件］，原型为gpointer ，即空指针）与某个构件相关连。关联后即可通过构件＋相应的key获取到相应的指针。Code#include<gtk/gtk.h>voidobject_data_get(GtkWidget*wid){...
glib单向列表
pdw2009的专栏
01-31 568
#include #include #define null NULL; void display_list(GSList *list) {     GSList *iterator = NULL;     for (iterator = list; iterator; iterator = iterator->next) {         printf("%s
GLib介绍与使用
duoerbasilu
07-26 354
GLib是一种底层库，创建GDK和GTK应用程序时该库提供许多有用的定义和函数。 包括基本类型及限制的定义、标准宏、类型转化、字节序、存储分配、警告和断言、消息记录、计时器、字符串工具、hook函数、句法扫描器、动态加载模块和字符串自动补全，同时也提供了许多数据类型及相关操作。包括存储块、双向链表、单向链表、哈希表、动态列表、关系和元组及缓存。最后GLib具有很好的移植性，所以使用GLib作为底...
查询下拉框案例，代替datalist对象。
qq_25775675的博客
03-11 791
代码 html： <input class="searchInput" itemIndex="{{$index}}" placeholder="请输入搜索关键字" type="text" value=""> <div id="dataDownListOutDiv"> <div class="dataDownList" ng-repeat='pl in ...
Glib学习笔记(4)
Innost的专栏
04-13 7949
四 数据结构这部分非常重要。4.1 内存片管理memory slices是一个高效的分配和管理等尺寸的类。这个和普通的new/delete相比有什么特别之处？似乎更高效，有分布式内存管理“之嫌“。建议替代g_malloc系列。没看出什么特别之处啊，暂时用malloc。包括一个过时的gmemchunk类，这里不叙述了。4.2 双/单向链表GList是双向链
GLIB 常用数据结构介绍 (1)
01-20 6200
int main(int argc, char** argv) { GSList* list = NULL; list = g_slist_append(list, "second"); list = g_slist_prepend(list, "first");g_printf("The list is now %d items long/n", g_slist_length(list)); l
glib库单向链表GSList介绍
热门推荐
plusboy的专栏
01-19 1万+
glib库单向链表介绍glib库里实现了一些基本的数据结构，比如单向链表，双向链表、队列、树、hash表和数组。这篇文章里我主要介绍在linux平台下使用glib库中的单向链表进行编程，以后的文章我会陆续介绍双向链表、队列和其它数据结构的用法。单向链表（即GSList）是glib库里最简单的容具，它把一系列的节点链接在一起，可以从一个节点访问到下一个节点。glib库里对GSList结构的定义如
g_object_weak_ref的意义和用途
国产开源 GUI 引擎 AWTK
01-17 4983
g_object_weak_ref的意义和用途 转载时请注明出处和作者联系方式：http://blog.csdn.net/absurd作者联系方式：Li XianJing 更新时间：2007-1-17 引用计数是控制对象生命周期常用的手法，对象初始引用计数为一，引用一次计数加一，反引用一次计数减一，直到计数降为零时，对象被销毁。GObject也实现了引用计数机制，g_obj
GLIB库编程之链表 --- GSlist & Glist
六六哥的博客
07-15 1886
用户空间不用自己编写数据结构，使用GLIB的工具是一个非常好的方式，下面的代码展示GLIB的链表的编程示例 #include <stdlib.h> #include <stdio.h> #include <glib.h> /* * 需要安装 * yum install glib2-devel.x86_64 * * 编译方法 * gcc glist_eg.c -g -O0 -lglib-2.0 -I /usr/include/glib-2.0.
一个GUI例子 Linux －－－－gshortcut
Antan技术专栏
01-31 1436
gshortcut  程序是一个给xfce desktop environment for NIX创建桌面快捷方式的一个工具。开发人：antan 代码解析：该程序共包括的源程序文件有：main.c interface.h interface.c support.h support.c callbacks.h callbacks.c其中：interface.h interface.c为界面设计的程序
g_object_new_with_properties方法在glib的哪里
最新发布
05-25
g_object_new_with_properties方法在GLib的Object类型的源文件"gobject/gobject.c"中实现。该方法是从g_object_newv()方法派生而来的，它允许在创建新对象时设置属性。它接受一个GObjectClass指针和一个NULL结束的GParameter数组作为参数，其中每个元素表示一个属性及其值。这些参数被用来设置新对象的属性值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值