C++自学篇 以类似结构体数组的形式生成与解析数据流

已于 2023-11-03 23:52:24 修改
阅读量65 收藏
点赞数
分类专栏： C++自学历程 文章标签： c++
于 2023-11-03 16:56:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42842270/article/details/134206307
版权

前言：
实际工程面临 进程A需要将发送类似结构体数组给进程B，即发送的数据流需要分为多组数据，每组可包含不同类型的数据，但每一组数据的类型必须一致。
因此开发数据流生成与数据流解析的demo。

结构体数组 数据流demo

代码分为2个文件：test.hpp、test.cpp

demo备注：

demo展示的数据流主要用于 进程到进程 / 核到核 / 端到端 之间的通信。
demo展示的数据流主要用于传输 类似 结构体数组（数据流的格式）的数据，一次可传输多组数据，每组数据可包含不同类型的数据。
数据流的格式为：
property1,property2,property3,property4;INT,ULONG,FLOAT,STRING;-1,1,1.100000,Aa1
string类型的数据不允许包含字符：“,”（组内数据分隔符）、“;”（组间数据分隔符），没有对其余字符做限制。
demo除了main函数、makeDataSteam1函数需要根据实际场景做修改，其他函数基本不需要修改。

demo：

test.hpp文件：

#pragma once

#include <vector>
#include <string>

enum PropertyDataTypeIndex {
    E_DATA_TYPE_INT = 0,
    E_DATA_TYPE_ULONG,
    E_DATA_TYPE_FLOAT,
    E_DATA_TYPE_STRING,

    E_DATA_TYPE_NUM,
    E_DATA_TYPE_NONE,
};

typedef struct {
    int dataType;

    int intItemData;
    unsigned long ulongItemData;
    float floatItemData;
    std::string stringItemData;
} ItemProperty_t;

typedef struct {
    int dataTypeIndex;
    std::string dataType;
} DataType_t;

typedef struct {
    std::string property;
    int dataTypeIndex;
} PropertyType_t;

std::string GetDataType(unsigned int index);
unsigned int GetDataTypeIndex(std::string dataType);
std::string makePropertyDataSteam(const PropertyType_t *propertyTypeList,
                                  int propertyTypeListSize,
                                  const std::string &segmentSeparatorSymbol,
                                  const std::string &teamSeparatorSymbol);
std::string makeTypeDataSteam(const PropertyType_t *propertyTypeList,
                              int propertyTypeListSize,
                              const std::string &segmentSeparatorSymbol,
                              const std::string &teamSeparatorSymbol);
int CalcGroupNum(const std::string &dataSteam,
                 const std::string &segmentSeparatorSymbol,
                 const std::string &teamSeparatorSymbol);
std::vector<int> GetPropertyType(const std::string &dataSteam,
                                 const std::string &segmentSeparatorSymbol,
                                 const std::string &teamSeparatorSymbol);
std::vector<std::vector<ItemProperty_t>> GetPropertyData(const std::string &dataSteam,
                                                         const std::vector<int> &propertyType,
                                                         const std::string &dataSteamHeader,
                                                         const std::string &segmentSeparatorSymbol,
                                                         const std::string &teamSeparatorSymbol);
std::string makeDataSteam1(const PropertyType_t *propertyTypeList,
                           int propertyTypeListSize,
                           const std::string &segmentSeparatorSymbol,
                           const std::string &teamSeparatorSymbol);
std::vector<std::vector<ItemProperty_t>> ParseData(const std::string &input,
                                                   const PropertyType_t *propertyTypeList,
                                                   int propertyTypeListSize,
                                                   const std::string &segmentSeparatorSymbol,
                                                   const std::string &teamSeparatorSymbol);

test.cpp文件：

#include <iostream>
#include <string>
#include <vector>
#include <sstream>

#include "test_01.hpp"

const DataType_t g_dataTypeList[] = {
    {E_DATA_TYPE_INT, "INT"},
    {E_DATA_TYPE_ULONG, "ULONG"},
    {E_DATA_TYPE_FLOAT, "FLOAT"},
    {E_DATA_TYPE_STRING, "STRING"},
};

std::string GetDataType(unsigned int index)
{
    std::string ret = "";

    if (index >= E_DATA_TYPE_NUM) {
        return ret;
    }

    for (int i = 0; i < (sizeof(g_dataTypeList) / sizeof(g_dataTypeList[0])); i++) {
        if (g_dataTypeList[i].dataTypeIndex == index) {
            ret = g_dataTypeList[i].dataType;
            break;
        }
    }

    return ret;
}

unsigned int GetDataTypeIndex(std::string dataType)
{
    unsigned int ret = E_DATA_TYPE_NONE;

    for (int i = 0; i < (sizeof(g_dataTypeList) / sizeof(g_dataTypeList[0])); i++) {
        if (g_dataTypeList[i].dataType == dataType) {
            ret = g_dataTypeList[i].dataTypeIndex;
            break;
        }
    }

    return ret;
}

std::string makePropertyDataSteam(const PropertyType_t *propertyTypeList,
                                  int propertyTypeListSize,
                                  const std::string &segmentSeparatorSymbol,
                                  const std::string &teamSeparatorSymbol)
{
    std::string dataSteam = "";

    if ((propertyTypeList == nullptr) || (propertyTypeListSize == 0)) {
        return dataSteam;
    }

    for (int i = 0; i < propertyTypeListSize; i++) {
        dataSteam += propertyTypeList[i].property;
        dataSteam += segmentSeparatorSymbol;
    }

    dataSteam.pop_back();
    dataSteam += teamSeparatorSymbol;

    return dataSteam;
}

std::string makeTypeDataSteam(const PropertyType_t *propertyTypeList,
                              int propertyTypeListSize,
                              const std::string &segmentSeparatorSymbol,
                              const std::string &teamSeparatorSymbol)
{
    std::string dataSteam = "";

    if ((propertyTypeList == nullptr) || (propertyTypeListSize == 0)) {
        return dataSteam;
    }

    for (int i = 0; i < propertyTypeListSize; i++) {
        dataSteam += GetDataType(propertyTypeList[i].dataTypeIndex);
        dataSteam += segmentSeparatorSymbol;
    }

    dataSteam.pop_back();
    dataSteam += teamSeparatorSymbol;

    return dataSteam;
}

int CalcGroupNum(const std::string &dataSteam,
                 const std::string &segmentSeparatorSymbol,
                 const std::string &teamSeparatorSymbol)
{
    int dataItemCnt = 0;

    std::string token;
    std::istringstream iss(dataSteam.substr());

    while (std::getline(iss, token, *segmentSeparatorSymbol.c_str())) {
        std::istringstream tokenStream(token);
        std::string propertyName = "";

        if (std::getline(tokenStream, propertyName, *segmentSeparatorSymbol.c_str())) {
            if (propertyName == "") {
                std::cout << "The property string format Abnormal." << std::endl;
                break;
            }
            dataItemCnt++;
        }
    }

    return dataItemCnt;
}

std::vector<int> GetPropertyType(const std::string &dataSteam,
                                 const std::string &segmentSeparatorSymbol,
                                 const std::string &teamSeparatorSymbol)
{
    std::vector<int> propertyType;

    std::string dataSteamType = dataSteam;
    dataSteamType.pop_back();

    std::string token;
    std::istringstream iss(dataSteamType.substr());

    while (std::getline(iss, token, *segmentSeparatorSymbol.c_str())) {
        std::istringstream tokenStream(token);
        std::string propertyName = "";

        if (std::getline(tokenStream, propertyName, *segmentSeparatorSymbol.c_str())) {
            if (propertyName == "") {
                std::cout << "The property string format Abnormal." << std::endl;
                break;
            }

            propertyType.push_back(GetDataTypeIndex(propertyName));
        }
    }

    return propertyType;
}

std::vector<std::vector<ItemProperty_t>> GetPropertyData(const std::string &dataSteam,
                                                         const std::vector<int> &propertyType,
                                                         const std::string &dataSteamHeader,
                                                         const std::string &segmentSeparatorSymbol,
                                                         const std::string &teamSeparatorSymbol)
{
    std::vector<std::vector<ItemProperty_t>> propertyData;

    std::istringstream propertyIss(dataSteam.substr(dataSteamHeader.length()));
    std::string propertyToken;

    for (int i = 0; (std::getline(propertyIss, propertyToken, *teamSeparatorSymbol.c_str())); i++) { // 遍历每一组
        std::istringstream groupIss(propertyToken);
        std::string groupToken;

        std::vector<ItemProperty_t> groupData;

        for (int j = 0; (std::getline(groupIss, groupToken, *segmentSeparatorSymbol.c_str())); j++) { // 遍历每个属性
            std::istringstream itemIss(groupToken);
            std::string itemString;
            ItemProperty_t itemProperty;

            if (std::getline(itemIss, itemString, *segmentSeparatorSymbol.c_str())) {
                if (itemString == "") {
                    std::cout << "The property string format Abnormal." << std::endl;
                    break;
                }

                switch (propertyType[j]) {
                case E_DATA_TYPE_INT:
                    itemProperty.intItemData = std::stoi(itemString);
                    itemProperty.dataType = propertyType[j];
                    break;

                case E_DATA_TYPE_ULONG:
                    itemProperty.ulongItemData = std::stoul(itemString);
                    itemProperty.dataType = propertyType[j];
                    break;

                case E_DATA_TYPE_FLOAT:
                    itemProperty.floatItemData = std::stof(itemString);
                    itemProperty.dataType = propertyType[j];
                    break;

                case E_DATA_TYPE_STRING:
                    itemProperty.stringItemData = (itemString);
                    itemProperty.dataType = propertyType[j];
                    break;

                default:
                    itemProperty.dataType = E_DATA_TYPE_NONE;
                    break;
                }

                groupData.push_back(itemProperty);
            }
        }

        propertyData.push_back(groupData);
    }

    return propertyData;
}

std::vector<std::vector<ItemProperty_t>> ParseData(const std::string &input,
                                                   const PropertyType_t *propertyTypeList,
                                                   int propertyTypeListSize,
                                                   const std::string &segmentSeparatorSymbol,
                                                   const std::string &teamSeparatorSymbol)
{
    std::vector<std::vector<ItemProperty_t>> result;
    std::vector<int> propertyType;

    std::string dataSteamHeader = "";
    std::string dataSteamProperty = makePropertyDataSteam(propertyTypeList, propertyTypeListSize, segmentSeparatorSymbol, teamSeparatorSymbol);
    std::string dataSteamType = makeTypeDataSteam(propertyTypeList, propertyTypeListSize, segmentSeparatorSymbol, teamSeparatorSymbol);

    dataSteamHeader += dataSteamProperty;
    dataSteamHeader += dataSteamType;

    // 1. calc group data num
    int dataItemNum = CalcGroupNum(dataSteamProperty, segmentSeparatorSymbol, teamSeparatorSymbol);
    if (dataItemNum == 0) {
        return result;
    }

    // 2. check header data
    if (input.substr(0, dataSteamHeader.length()) != dataSteamHeader) {
        std::cout << "The input string format Abnormal." << std::endl;
        return result;
    }

    // 3. get data type
    propertyType = GetPropertyType(dataSteamType, segmentSeparatorSymbol, teamSeparatorSymbol);
    if (propertyType.size() != dataItemNum) {
        std::cout << "The property type num Abnormal." << propertyType.size() << dataItemNum << std::endl;
        return result;
    }

    // 4. get data
    result = GetPropertyData(input, propertyType, dataSteamHeader, segmentSeparatorSymbol, teamSeparatorSymbol);

    return result;
}

std::string makeDataSteam1(const PropertyType_t *propertyTypeList,
                           int propertyTypeListSize,
                           const std::string &segmentSeparatorSymbol,
                           const std::string &teamSeparatorSymbol)
{
    std::string dataSteam = "";
    std::string dataSteamProperty = makePropertyDataSteam(propertyTypeList, propertyTypeListSize, segmentSeparatorSymbol, teamSeparatorSymbol);
    std::string dataSteamType = makeTypeDataSteam(propertyTypeList, propertyTypeListSize, segmentSeparatorSymbol, teamSeparatorSymbol);

    dataSteam += dataSteamProperty;
    dataSteam += dataSteamType;

    struct DataSteamStruct {
        int property1;
        unsigned int property2;
        float property3;
        std::string property4;
    };

    DataSteamStruct dataSteamList[] = {
        {-1, 1, 1.1, "Aa1"},
        {-2, 2, 2.2, "2000 / 2 / 2"},
        {-3, 3, 3.3, "13 : 30"},
        {-4, 4, 4.4, "4 - 4"},
        {-5, 5, 5.5, "5 # 5"},
        {-6, 6, 6.6, "6 % 6"},
        {-7, 7, 7.7, "7 [] 7"},
        {-8, 8, 8.8, "8 () 8"},
        {-9, 9, 9.9, "9 <> 9"},
    };
    int dataSteamListSize = sizeof(dataSteamList) / sizeof(dataSteamList[0]);

    for (int i = 0; i < dataSteamListSize; i++) {
        dataSteam += std::to_string(dataSteamList[i].property1);
        dataSteam += segmentSeparatorSymbol;
        dataSteam += std::to_string(dataSteamList[i].property2);
        dataSteam += segmentSeparatorSymbol;
        dataSteam += std::to_string(dataSteamList[i].property3);
        dataSteam += segmentSeparatorSymbol;
        dataSteam += (dataSteamList[i].property4);
        dataSteam += teamSeparatorSymbol;
    }

    dataSteam.pop_back();

    return dataSteam;
}

int main(int argc, char *argv[])
{
    // 数据流主要用于 进程到进程 / 核到核 / 端到端 之间的通信
    // 数据流主要用于传输 类似 结构体数组（数据流的格式）的数据，一次可传输多组数据，每组数据可包含不同类型的数据
    // 数据流的格式为：
    // "^property1,property2,property3,property4;INT,ULONG,FLOAT,STRING;-1,1,1.100000,Aa1$"
    // 注：
    // string类型的数据不允许包含字符：“,”（组内数据分隔符）、“;”（组间数据分隔符），没有对其余字符做限制
    const std::string segmentSeparatorSymbol = ",";
    const std::string teamSeparatorSymbol = ";";

    const PropertyType_t propertyTypeList[] = {
        {"property1", E_DATA_TYPE_INT},
        {"property2", E_DATA_TYPE_ULONG},
        {"property3", E_DATA_TYPE_FLOAT},
        {"property4", E_DATA_TYPE_STRING},
    };
    const int propertyTypeListSize = sizeof(propertyTypeList) / sizeof(propertyTypeList[0]);

    std::string testInputDataSteam_1 = makeDataSteam1(propertyTypeList,
                                                      propertyTypeListSize,
                                                      segmentSeparatorSymbol,
                                                      teamSeparatorSymbol);
    printf("DataSteam:\n");
    printf("\"%s\"\n", testInputDataSteam_1.c_str());

    std::vector<std::vector<ItemProperty_t>> parsedData_1 = ParseData(testInputDataSteam_1,
                                                                      propertyTypeList,
                                                                      propertyTypeListSize,
                                                                      segmentSeparatorSymbol,
                                                                      teamSeparatorSymbol);

    printf("DataParse:\n");
    for (int i = 0; i < parsedData_1.size(); i++) {
        printf("[%d]\n", i);

        for (int j = 0; j < parsedData_1[i].size(); j++) {
            switch (parsedData_1[i][j].dataType) {
                case E_DATA_TYPE_INT:       printf("\t[%d]: %d\n", j, parsedData_1[i][j].intItemData);      break;
                case E_DATA_TYPE_ULONG:     printf("\t[%d]: %u\n", j, parsedData_1[i][j].ulongItemData);    break;
                case E_DATA_TYPE_FLOAT:     printf("\t[%d]: %.2f\n", j, parsedData_1[i][j].floatItemData);  break;
                case E_DATA_TYPE_STRING:    printf("\t[%d]: \"%s\"\n", j, parsedData_1[i][j].stringItemData.c_str());   break;
                default:                    printf("\t[%d]: None\n", j);                                    break;
            }
        }
    }

    return 0;
}

运行结果如下：

DataSteam:
"property1,property2,property3,property4;INT,ULONG,FLOAT,STRING;-1,1,1.100000,Aa1;-2,2,2.200000,2000 / 2 / 2;-3,3,3.300000,13 : 30;-4,4,4.400000,4 - 4;-5,5,5.500000,5 # 5;-6,6,6.600000,6 % 6;-7,7,7.700000,7 [] 7;-8,8,8.800000,8 () 8;-9,9,9.900000,9 <> 9"
DataParse:
[0]
        [0]: -1
        [1]: 1
        [2]: 1.10
        [3]: "Aa1"
[1]
        [0]: -2
        [1]: 2
        [2]: 2.20
        [3]: "2000 / 2 / 2"
[2]
        [0]: -3
        [1]: 3
        [2]: 3.30
        [3]: "13 : 30"
[3]
        [0]: -4
        [1]: 4
        [2]: 4.40
        [3]: "4 - 4"
[4]
        [0]: -5
        [1]: 5
        [2]: 5.50
        [3]: "5 # 5"
[5]
        [0]: -6
        [1]: 6
        [2]: 6.60
        [3]: "6 % 6"
[6]
        [0]: -7
        [1]: 7
        [2]: 7.70
        [3]: "7 [] 7"
[7]
        [0]: -8
        [1]: 8
        [2]: 8.80
        [3]: "8 () 8"
[8]
        [0]: -9
        [1]: 9
        [2]: 9.90
        [3]: "9 <> 9"
凌X绦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OJ系统读入数据流的方法总结C++
雪水
06-17 2077
样例输入： 3,1,2 1,2,3,4,5 345,2324,11,2,4,0,9 对于这样的输入，应该先采用getline()函数获得一行数据，然后将这个字符串中数字取出。从字符串转换为int或者其他类型有三种方式
c++ 如何将结构体转化成json_使用cJSON创建JSON字符串
weixin_33321637的博客
12-26 2668
最近需要用单片机解析esp8266模块get到的json数据，顺便学习了下cJSON的知识，当作一个笔记吧，分享出来大家一起学习。这个是创建JSON字符串，后面还有解析。1，下载源码最新版的cJson源码可以从github上进行下载。2，包含cJSON的源码下载下来，解压后，从里面找到两个文件(cJSON.c、cJSON.h)，复制到我们的工程里面。只需在函数中包含头文件(#include “cJ...
c++中数据流 （1）
database_zbye的专栏
09-16 3455
今天在c++读写文件时遇到了一个问题，在这个上面遇到了解决方案，还得多多学习流机制啊。 http://zhidao.baidu.com/question/24192048.html&__bd_tkn__=75b4466937389f3854539374a1a56bb2c706a5a78078338d51fed8133ea5c69d362ad36bb4bcda3b39bb3949f6bbe4708
c++标准库简介（数据流）
10-26
c++标准库简介，数据流，iostream，fstream，strstream
C++I/O流详解
qq_52905520的博客
12-03 2550
C++ I/O流详解
c++字节流与结构体互转
ZHYFXY的博客
11-13 2870
c++是类型不安全的，一般字节流和结构体是可以互相强转的，但前提是字节流要像结构体一样进行数据对齐，下面就来看看按数据大小依次排列的字节流是如何转化为结构体的： 基础依赖部分代码： #include <stdio.h> #include <windows.h> #include <list> namespace sangame { #define H8_...
C#调用C++DLL传递结构体数组的终极解决方案
08-31
【C#调用C++DLL传递结构体数组的终极解决方案】 在C#和C++混合编程中，常常需要跨语言调用DLL中的函数，而结构体数组是常见的数据...遵循这些步骤，可以确保C#与C++之间结构体数组的顺利传递，实现跨语言的有效通信。
基于C#调用c++Dll结构体数组指针的问题详解
08-28
基于C#调用C++ Dll结构体数组指针的问题详解 C#调用C++ Dll文件是一件很麻烦的事情，首先面临的是数据类型转换的问题。相信经常做C#开发的都和我一样把学校的那点C++基础都忘光了吧（语言特性类）。网上有一大堆得...
C++结构体数组详细解析
12-31
和定义结构体变量类似，定义结构体数组时只需声明其为数组即可。如： 代码如下:struct Student{ int num; char name[20]; char sex[5]; int age; float score; char addr[30];};Student stu[3]; //定义Student...
C++语言结构体介绍和结构体数组使用示例
最新发布
12-24
结构体（struct）是C++中一种用户自定义的数据类型，它允许我们将多个不同类型的数据组合在一起，形成一个单一的数据结构。结构体可以包含任意类型的数据，包括基本数据类型、数组、指针、结构体等。 结构体（struct...
数据流中的中位数(剑指offer/C++)
weixin_37725502的博客
10-04 649
题目描述 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。 室友大晚上回来和我分享这道题解题思路，他给出的方案是借助最大堆和最小堆数据结构解题，这一块我应用不是很...
数据流分析（一）
热门推荐
电影旅行敲代码
02-21 2万+
引子编译器后端会对前端生成的中间代码做很多优化，也就是在保证程序语义不变的前提下，提高程序执行的效率或减少代码size等优化目标。优化需要依靠代码分析给出的“指导信息”来相应地改进代码，而代码分析中最重要的就是数据流分析。另外数据流分析是程序静态分析的基础。所以掌握数据流分析对编译后端极为重要。 何为数据流分析 数据流抽象 数据流分析模式 基本块上的数据流模式 何为数据流分析 数据流分析指的是一
c++用标准输入输出流测试数据
sunlanchang的博客
04-17 1747
在测试很多数据时候往往要重新输入很多数据，如果用标准输入输出流测试数据往往会非常的方便。在这里写一个小的demo方便理解记忆。#include <cstdio> #include <iostream> using namespace std; int main() { int a, b; freopen("in.txt", "r", stdin); //输入重定向，输入数据将从i
剑指offer（C++）——数据流中的中位数
YF_Li123的博客
04-19 2701
题目描述 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。 思路：由于数据是从数据流中读取出来的，数据的个数随着时间的变化而增加。因此我们需要一个数据容器来保存读取出来的数据。 解法1：用数组来保存数据。如果数组无序，则找到中位数最优的算法时间
C++:数据流和缓冲区
wishchinYang的专栏
10-22 3861
使用缓冲区是C++编程的一种有效方式，本文做了简单介绍
数据流中的中位数 C++实现
因每天学习而伟大
07-13 1315
题目描述如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。class Solution {public:    void Insert(int num)    {        if(more.empty())        {            more.p...
c语言中的数据流
f81892461的专栏
01-17 6419
stdout, stdin, stderr的中文名字分别是标准输出，标准输入和标准错误。在Linux下，当一个用户进程被创建的时候，系统会自动为该进程创建三个数据流。什么是数据流呢（stream）？我们知道，一个程序要运行，需要有输入、输出，如果出错，还要能表现出自身的错误。这是就要从某个地方读入数据、将数据输出到某个地方，这就够成了数据流。 因此，一个进程初期所拥有的这么三个数据流，就分别是标
c++动态生成结构体数组
09-06
您可以使用动态内存分配来动态生成结构体数组。以下是一个示例代码： ```c #include #include typedef struct { int id; char name[20]; } Student; int main() { int size; printf("请输入学生人数："); ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值