嵌入式养成计划-37----C++内存动态分配与回收--C++类中特殊的成员函数

已于 2023-10-10 20:14:13 修改
阅读量362 收藏 1
点赞数
文章标签： c++ 开发语言
于 2023-10-09 20:29:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52625576/article/details/133713049
版权
本文详细介绍了C++中内存动态分配（new,delete,malloc,free）的区别，以及类中的构造函数（包括无参、有参和初始化列表）、析构函数、拷贝构造函数和浅拷贝/深拷贝的概念。
摘要由CSDN通过智能技术生成

八十五、 C++内存动态分配与回收

  • C语言中的动态内存分配和回收是用malloc、free来完成的
  • C++中也可以用上述两个函数来完成。
  • C++中也为用户提供了两个关键字来进行动态内存分配和回收 new 、delete

85.1 分配

  • 单个内存分配
    格式： 数据类型 *指针名 = new 数据类型
    • 例如： int *p1 = new int;
      //此时表示在堆区中申请一个整型大小的空间，把地址赋给p
  • 连续内存分配
    格式：数据类型 * 指针名 = new 数据类型[个数]
    • 例如： int *p2 = new int[5];
      //在堆区中连续申请5个整型大小的空间

85.2 回收

  • 单个内存回收
    格式： delete 指针名
    • 例如： delete p1;
  • 连续内存回收
    格式：delete [ ]指针名
    • 例如 : delete [ ]p2;

85.3 new、delete 和malloc 、free之间的区别 （笔试面试题）

  • new delete 是关键字，malloc free是函数
  • new申请空间是以数据类型为单位，malloc申请空间是字节单位
  • new可以申请空间是初始化，malloc申请空间不会
  • new申请空间是什么类型指针就是什么类型，malloc返回值是void*，需要强制转换才能使用。
  • new 申请对象空间时，会自动调用构造函数，而malloc不会
  • delete释放对象空间时，会自动调用析构函数，而free不会

85.4 示例：

#include <iostream>
using namespace std;
int main()
{
    //在堆区空间中申请int大小空间
    int *p1 = new int;
    cout << *p1 << endl;

    *p1 = 1314;
    cout << *p1 << endl;

    //在堆区空间中申请int大小空间并初始化
    int *p2 = new int(10);
    cout << *p2 << endl;

    //在堆区空间中申请char大小空间并初始化
    char *p3 = new char('H');
    cout << *p3 << endl;
    
    //释放（回收）内存空间
    delete p1;
    delete p2;
    delete p3;
    cout << "----------------------" << endl;
    //在堆区空间中连续申请5个int大小空间
    int *p4 = new int[5];
    for(int i=0; i<5; i++)
    {
        cout << p4[i] << endl;
    }
    cout << "----------------------" << endl;
    //在堆区空间中连续申请5个int大小空间并初始化
    int *p5 = new int[5]{100,200,300,400,500};
    for(int i=0; i<5; i++)
    {
        cout << p5[i] << endl;
    }
    //释放（回收）连续内存
    delete []p4;
    delete []p5;

    //给指针来个指向 避免野指针
    p1 = nullptr;
    p2 = nullptr;
    p3 = nullptr;
    p4 = nullptr;
    p5 = nullptr;
    return 0;
}

八十六、 C++类中特殊的成员函数

  • 特殊函数种类： 构造函数、析构函数、拷贝构造函数、拷贝赋值函数、移动赋值、移动拷贝、取地址运算符、常取地址运算符
  • 特殊原因：
    1. 这些函数无需程序员手动定义，系统会默认提供，如果程序员手动定义，那么系统就取消默认提供。
    2. 这些函数无需程序员手动调用，在特定的条件下，系统自动调用，即使是程序员手动定义的函数。

86.1 构造函数

86.1.1 功能

  • 在类实例化对象时，会自动调用构造函数来给类对象申请空间以及初始化。

86.1.2 格式

  • 函数名：与类同名
  • 返回值：无 也无void
  • 参数：可以有参数，可以无参数
  • 权限：一般为public
类名(形参列表)
{
    函数体内容;
}

86.1.3 调用时机

  • 类实例化对象时，会自动调用构造函数。
  • 栈区
    • 何时实例化对象，何时调用构造函数
      形式 ：类名 对象(实参)；
  • 堆区
    • 何时使用new ,何时调用构造函数

示例：

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int id;
public:
    Stu()  //无参构造函数 由系统默认提供
    {
        cout << "Stu::无参构造函数" << endl;
    }
    Stu(string name, int id)
    {
        this->name = name;
        Stu::id = id;
        cout << "Stu::有参构造函数" << endl;
    }
    void show()
    {
        cout << "姓名：" << name << "   学号：" << id << endl;
    }
};
int main()
{
    Stu s1; //自动调用无参构造函数
    Stu s2("张三", 1001); //自动调用有参构造函数
    s2.show();
    return 0;
}

86.1.4 注意

  • 系统会提供一个默认无参构造函数。
    如果自己写了有参构造函数，会把系统提供的默认无参构造函数给屏蔽掉。
    如果想使用无参构造函数，则需要显性定义出无参构造函数，否则报错。
  • 构造函数中可以给定默认参数值。

86.1.5 初始化列表

  • 构造函数的本身功能是完成给对象申请空间的，初始化工作是由初始化列表完成。
  • 初始化列表格式：
    由构造函数形参列表后的小括号后面由冒号引出
    类名 (形参1，形参2，形参n):成员变量1(形参1),成员变量2(形参2),······,成员变量n(形参n)
  • 必须使用初始化列表的情况：
    1. 当类中有常成员变量时，对该变量的初始化必须使用初始化列表来完成。
    2. 当类中有引用变量时，对该变量的初始化必须使用初始化列表来完成。
    3. 当类中有其他类的子对象时，对该子对象的初始化必须使用初始化列表来完成。
  • 注意：只有构造函数才有初始化列表，其他普通函数没有初始化列表。

示例：

#include <iostream>
using namespace std;
class Bir
{
private:
    int year;
    int month;
    int day;
public:
    Bir(int y,int m, int d):year(y),month(m),day(d)
    {
        cout << "Bir::有参构造函数" << endl;
    }
};

class Stu
{
private:
    string name;
    int id;
    Bir bir;
public:
    //无参构造函数
	//Stu() {}

    //有参构造函数
    Stu(string name, int id, int y,int m, int d):name(name),id(id),bir(y,m,d)
    {
        cout << "Stu::有参构造函数" << endl;
    }
    void show(){cout << name;}
};
int main()
{
    Stu s1("zhangsan", 1001, 2002, 9, 9); //先调用子对象的构造函数，再调用自己的构造函数
    return 0;
}

86.2 析构函数

86.2.1 功能

  • 当类对象生命周期结束后，自动调用析构函数，来对类对象回收资源（释放空间）。

86.2.2 格式

  • 函数名：~类名
  • 返回值：无 无void
  • 参数：无参数
  • 权限：一般是public
~类名()
{
    函数体内容;
}

86.2.3 调用时机

  • 类对象生命周期结束后，会自动调用析构函数。
  • 栈区
    • 当类对象所在的函数结束时，自动调用析构函数
  • 堆区
    • 何时使用delete ,何时调用析构函数

示例 ：

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int id;
public:
    //无参构造函数
    Stu() {cout << "Stu::无参构造函数" << endl;}
    //有参构造函数
    Stu(string name, int id):name(name),id(id)
    {
        cout << "Stu::有参构造函数" << endl;
    }
    //析构函数
    ~Stu()
    {
        cout << "Stu::析构函数" << endl;
        cout << this << endl;
    }
    void show()
    {
        cout << name << endl;
    }
};
int main()
{
    Stu s1; //自动调用无参构造
    Stu s2("zhangsan", 1001); //自动调用有参构造函数
    cout << "&s1 = " << &s1 << "     &s2 = " << &s2 << endl;
    //先构造的 后析构   后构造的 先析构
    return 0;
}

在这里插入图片描述
在这里插入图片描述

小结：

  1. 类中都系统默认提供析构函数，如果显性定义了析构函数，则系统取消默认提供。
  2. 当类中的成员变量有指针并且这个指针成员变量在堆区申请了空间，则此时需要显性定义析构函数，并且在析构函数中手动将指针成员所申请的空间释放，避免内存泄漏。
  3. 每个类中只有一个析构函数，原因：析构函数没有参数，所以不能重载。
#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int id;
    double *score; //有指针成员变量时，并申请了堆区空间
public:
    //无参构造函数
    Stu() {cout << "Stu::无参构造函数" << endl;}
    //有参构造函数
    Stu(string name, int id, double b):name(name),id(id),score(new double(b))
    {
        //score = new double(b);
        cout << "Stu::有参构造函数" << endl;
    }
    //析构函数
    ~Stu()
    {
        cout << "Stu::析构函数" << endl;
        cout << this << endl;
        delete score;  //需要把析构函数显性定义出来，在其中把指针成员释放掉
    }
    void show(){cout << name << endl;}
};
int main()
{
    Stu s1; //自动调用无参构造
    Stu s2("zhangsan", 1001, 89); //自动调用有参构造函数
    cout << "&s1 = " << &s1 << "     &s2 = " << &s2 << endl;
    
    Stu *p = new Stu; //自动调用无参构造函数
    delete p; //自动调用析构函数
    return 0;
}

86.3 拷贝构造函数

86.3.1 功能

  • 拷贝构造函数其实就是一种特殊的构造函数，用一个类对象给另一个类对象初始化的。

86.3.2 格式

  • 函数名：与类同名
  • 返回值：无 无void
  • 参数： 同类的其他类对象
  • 权限：一般为public
类名(const 类名 &other)
{
    函数体内容
}

86.3.3 调用时机

  1. 用一个类对象给另一个类对象初始化时，自动调用拷贝构造函数
    eg:
    Stu s(s1);
    Stu s = s1;
  2. 当类对象作为函数的形参时， 实参传递给形参时，自动调用拷贝构造函数
  3. 当函数返回一个类对象时，自动调用拷贝构造函数

86.4 浅拷贝和深拷贝（笔试面试）

  1. 系统会提供一个默认的拷贝构造函数，如果自己显性定义出了拷贝构造函数，则系统会取消默认提供函数。
  2. 系统提供的拷贝构造函数，是把一个对象的所有数据成员初始化另一个对象的所有数据成员，叫浅拷贝

86.4.1 浅拷贝

  • 拷贝时，属性有指针，然而也直接拷贝了，这样新的对象和旧的对象的这个属性都指向了同一个内存空间，这个是浅拷贝，可以参考下图
    在这里插入图片描述

86.4.2 深拷贝

  • 拷贝时，属性有指针，没有直接拷贝有指针的属性，而是在拷贝时，让指针指向一个新的空间，再进行拷贝，如此，这俩指针就不会指向同一个地方了，这就是深拷贝，可以参考下图
    在这里插入图片描述

86.5 拷贝赋值函数

86.5.1 功能

  • 用一个类对象给另一个类对象赋值操作。
  • 本质上是赋值运算符重载。

86.5.2 格式

  • 函数名：operator=
  • 返回值：自身的引用
  • 参数：同类的其他类对象的引用
  • 权限：一般为public
类名 &operator=(const 类名&other)
{
    函数体内容;
}

86.5.3 调用时机

  • 用一个类对象给另一个类对象赋值操作时
#include <iostream>
using namespace std;

class Stu{
private:
    int* id;
    string name;
public:
    Stu ();                     //无参构造
    Stu(int id, string name);   //有参构造
    Stu(const Stu &other);      //拷贝构造
    ~Stu();                     //析构

    Stu &operator=(const Stu &other);

    //set
    void set_id(int id);
    void set_name(string name);

    //get
    int get_id();
    string get_name();

    //其他方法
    void show_info();

};
//无参构造
Stu::Stu(){
    cout << this->get_name() << " 调用了无参构造函数" << endl;
};
//有参构造
Stu::Stu(int id, string name):id(new int(id)),name(name)
{
    //    this->id = id;
    //    Stu::name = name;
    cout << this->get_name() << " 调用了有参构造函数" << endl;
}
//拷贝构造
Stu::Stu(const Stu &other):id(other.id),name(other.name)
{
    cout << this->get_name() << " 调用了拷贝构造函数" << endl;
}
//析构
Stu::~Stu(){
    cout << this->get_name() << " 调用了析构函数" << endl;
}

//拷贝赋值
Stu& Stu::operator=(const Stu &other){
    if(this != &other){
        id = new int(*other.id);
        name = other.name;
        cout << this->get_name() << " 调用了拷贝赋值函数" << endl;
    }
    return *this;
}


//set
void Stu::set_id(int id){
    *(this->id) = id;
}
void Stu::set_name(string name){
    this->name = name;
}
//get
int Stu::get_id(){
    return *(this->id);
}
string Stu::get_name(){
    return this->name;
}
//其他方法
void Stu::show_info(){
    cout << "id = " << *(this->id) <<endl;
    cout << "name = " << this->get_name() << endl;
}

int main()
{

    Stu s2(1010, "法外狂徒");
    Stu *p = new Stu(1020, "德玛西亚");
    Stu *p2 = new Stu(1030, "艾欧尼亚");
    Stu s1(s2);
    Stu s3;
    s3 = *p2;

    puts("");
    s1.show_info();
    s2.show_info();
    s3.show_info();
    (*p).show_info();
    (*p2).show_info();
    puts("");

    delete p;
    delete p2;
    return 0;
}

小作业：

设计一个Per类，
类中包含私有成员:
	姓名、年龄、指针成员身高、体重，

再设计一个Stu类，
类中包含私有成员:
	成绩、Per类对象p1，

设计这两个类的  构造函数、 析构函数  和  拷贝构造函数。

我写的：

class.h

#ifndef __CLASS_H__
#define __CLASS_H__

#include <iostream>
using namespace std;

class Pre
{
private:
    string name;
    int age;
    int *high;
    int *weight;

public:
    //构造函数
    Pre();
    Pre(string name, int age, int high, int weight);
    //析构函数
    ~Pre();
    //拷贝构造函数
    Pre(const Pre &other);
    //获取姓名
    string get_name();
};

class Stu
{
private:
    //构造函数
    int score;
    Pre p;
public:
    Stu();
    Stu(int score, Pre p);
    //析构函数
    ~Stu();
    //拷贝构造函数
    Stu(const Stu &other);
};

#endif // __CLASS_H__

pre.cpp

#include "class.h"

//构造函数
Pre::Pre(){
    cout << this->name << " 调用了无参构造函数" << endl;
}
Pre::Pre(string name, int age, int high, int weight){
    this->name = name;
    this->age = age;
    this->high = new int(high);
    this->weight = new int(weight);
    cout << this->name << " 调用了有参构造函数" << endl;
}
//析构函数
Pre::~Pre(){
    delete this->high;
    delete this->weight;
    cout << this->name << " 调用了析构函数" << endl;
}
//拷贝构造函数
Pre::Pre(const Pre &other){
    this->name = other.name;
    this->age = other.age;
    this->high = new int(*(other.high));
    this->weight = new int(*(other.weight));
    cout << this->name << " 调用了拷贝构造函数" << endl;
}
string Pre:: get_name(){
    return this->name;
}

stu.cpp

#include "class.h"

Stu::Stu(){
    cout << this->p.get_name() << " 调用了无参构造函数" << endl;
}
Stu::Stu(int score, Pre p){
    this->score = score;
    this->p = p;
    cout << this->p.get_name() << " 调用了有参构造函数" << endl;
}
//析构函数
Stu::~Stu(){
    cout << this->p.get_name() << " 调用了析构函数" << endl;
}
//拷贝构造函数
Stu::Stu(const Stu &other){
    this->score = other.score;
    this->p = other.p;
    cout << this->p.get_name() << " 调用了拷贝构造函数" << endl;
}

在这里插入图片描述

zhk___
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++内存管理
lesky的专栏
12-25 7365
C++内存管理[导语]内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自
C/C++ 程序占用内存的分配机制-释放和回收理解
PHP代码的博客
07-11 3945
C/C++ 程序占用内存的分配机制-释放和回收理解
c/c++ 内存动态分配与回收
weixin_30675967的博客
10-20 383
c语言提供内存的动态分配的函数有： malloc，calloc，realloc。在使用这些函数时，必须包含其头文件，分别为：<malloc.h>，<stdlib.h>，<alloc.h> 1.malloc函数 malloc函数原型： void *malloc（unsigned int size） 作用：在内存的动态分配区域中分配一个长度为siz...
嵌入式养成计划-26-IO进线程----进程
This code no bug！
09-10 329
若只退出子进程，而其父进程没有给子进程收尸的时候，子进程的资源没有被回收，此时子进程会变成僵尸进程。功能：显示进程关系树。
嵌入式养成计划-26-IO进线程----线程
This code no bug！
09-11 295
线程是一个进程并发执行多种任务的机制。串行，并发，并行。串行：多个任务之间，有先后顺序，有序运行。一个任务执行完毕后，才能执行另一个任务。并发：多个任务之间，在单核CPU上，根据时间片轮询机制运行，同一个时间只能运行一个任务，cpu根据时间片调度任务。并行：多个任务之间，在多核CPU上，同时运行。进程的上下文切换：上下文：运行一个进程所需要的所有内容。上下文切换：访问A进程时候的所有资源，切换到访问B进程的所有资源。这是一个耗时操作。
嵌入式八股-C++面试30题（20240814）
sagima_sdu的博客
08-14 452
将全局变量定义在头文件中可能导致重复定义问题。每个包含该头文件的源文件都会有该变量的定义，导致链接错误。解决方案是使用extern声明全局变量，并在一个源文件中定义它。内存泄露是指程序在堆上分配内存后未能正确释放，导致内存无法被再次使用，最终可能耗尽系统内存。面向对象是一种编程范式，强调将数据和操作数据的函数封装在对象内。封装：将数据和方法绑定在一起，对外隐藏实现细节。继承：允许新类继承现有类的特性和行为。多态：允许不同类的对象通过相同的接口调用不同的行为。
侯捷老师 C++内存管理-第一讲 学习笔记
weixin_56042518的博客
08-22 649
侯捷C++内存管理--第一讲 primitives
嵌入式全栈开发学习笔记---Linux系统编程(多线程编程)
最新发布
xiaobaivera的博客
08-31 700
什么叫线程？ 通俗来讲，线程就是“进程里面的进程”，叫执行流 就像这样，下图一个箭头代表一个进程，一个进程分为两个线程，一个线程可以单独处理一件事情，那一个进程里面有两个线程，也就是两个分支，这样一个进程就可以处理两件事情，而这两个线程是共享这一个进程的虚拟空间的。 线程的优势（面试重点） 和进程相比，它是一种非常“节俭”的多任务操作方式.，启动一个线程不需要分配内存资源。 线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。 线程有方便的通信机制（比如定义了一个全局变量，每个线程都可以使用，因为它们
C和C++面试--看的不多只看一篇
yaoming168的专栏
02-06 974
可以通过面试题的形式检验和巩固自己对于语言的掌握情况
【C/C++ 性能优化】提高C++程序的缓存命中率以优化性能
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
02-13 2244
在探讨计算机性能优化的旅程中，我们常常被引导去关注算法的复杂度、代码的优化，或是更高效的数据结构。然而，有一个经常被忽视的角色在幕后默默地影响着程序的运行效率——那就是缓存（Cache）。正如哲学家亨利·戴维·梭罗在《瓦尔登湖》中所说：“细节是造成美丽的源泉”，在软件开发的世界里，对缓存的理解和优化，就是那些决定程序性能优雅与否的细节。
C/C++内存泄漏与检测
十年代码写十年
07-21 1089
“该死系统存在内存泄漏问题”，项目中由于各方面因素，总是有人抱怨存在内存泄漏，系统长时间运行之后，可用内存越来越少，甚至导致了某些服务失败。内存泄漏是最难发现的常见错误之一，因为除非用完内存或调用malloc失败，否则都不会导致任何问题。实际上，使用C/C++这类没有垃圾回收机制的语言时，你很多时间都花在处理如何正确释放内存上。如果程序运行时间足够长，如后台进程运行在服务器上，只要服务器不宕机就一...
《果壳中的C# C# 5.0 权威指南》 (01-08章) - 学习笔记
GATTACA2011
02-05 1289
《果壳中的C# C# 5.0 权威指南》 ========== ========== ========== [作者] (美) Joseph Albahari (美) Ben Albahari [译者] (中) 陈昇 管学理 曾少宁 杨庆川 [出版] 中国水利水电出版社 [版次] 2013年08月 第1版 [印次] 2013年08月 第1次 印刷 [定价] 118.00元 ========== =...
孩子为什么要学JAVA---Java学习规划
yuan_dai_ma的博客
11-25 534
- **一种编程语言、一种开发环境、一种应用环境、一种部署环境。** - 简单来说Java是一门计算机编程语言，面向对象的编程语言，和外语类似，反而相比外语更有逻辑性，作为一门语言，有语法、词法，有规则、有“固定搭配”，目的也都是为了实现交流，人与人或人与机器，都是一个概念。
c++面试重要考点
m0_55494380的博客
09-10 1087
第一章 C++基本考点 1.1 命令空间 一个潜在的问题：使用两个已封装好的产品，而它们都含一个名字wanda()函数，当使用wanda（）函数时，编译器就不知道指的是哪个版本。命令空间让能够将产品封装叫做名称空间的单元中。这样就可以用命令空间的名称来指出想使用哪个厂商的产品。也就说，命令空间是用来把变量名封装起来。 下面一行代码表明，可以使用std名称空间中定义的名称，而不必使用std::前缀。 using namespace std; 但是在大型项目中...
C语言如何快速求值
2301_81985098的博客
08-26 1253
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数。一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？2、计算等式：m2 - n2 = (m + n)(m - n) = 168。1、则：x + 100 = n2, x + 100 + 168 = m2。6、由于 i * j = 168， j>=2，则。
c++命令模式
qq_71286244的博客
08-30 522
c++命令模式详细介绍
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 1951
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 3200
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
嵌入式Java-C/C++入门指南：解决小白问题与实战OTP动态令牌
该笔记着重讲述了作者从嵌入式开发小白到入门阶段的经历，包括遇到的问题、解决策略，以及一个名为"OTP动态令牌"的实际项目，该项目利用Java和C++技术构建，通过JNI（Java Native Interface）实现Java项目与C++动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zhk___

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

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

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

打赏作者

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

抵扣说明：

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

余额充值