C++学习笔记

已于 2024-03-07 16:42:02 修改
阅读量778 收藏 13
点赞数 19
文章标签： c++ 学习 笔记
于 2024-03-02 11:07:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zombie166/article/details/136372326
版权

一、编程之前的准备

使用notepad++更改根目录

打开VS文件位置->VC->VCProjectItems->使用notepad++编辑newc++file.cpp->更改成以下内容

保存

#include <iostream>
#include <string>
using namespace std;

int main()
{

	system("pause");
	
	return 0;
}//使用notepad++以管理员身份修改

二、变量和常量

同C语言

#include <iostream>
using namespace std;

int main()
{
    //设定变量
	int a = 1;
    cout << "a = " << a << endl;

	system("pause");
	
	return 0;
}
#include <iostream>
using namespace std;

#define day 7
//宏常量一般在程序头设定，且不可再函数中修改

int main()
{
	cout << "一周有 " << day << "天" << endl;
    //const修饰的变量为常量，不可修改。
    const int month = 30;
    cout << "一个月有 " << month << "天" << endl;

	system("pause");
	
	return 0;
}

三、数据类型

3.1整型

3.2sizeof关键字

sizeof(变量)可展示出变量闸弄也能够内存大小

3.3实型（浮点型）

#include <iostream>
using namespace std;

int main()
{
	//float 单精度
    //double 双精度
    float f1 = 3.14f;
    double f2 = 3.14;
    cout << "f1 =" << f1 << endl;
    cout << "f2 =" << f2 << endl;

    //一般最多保留六位小数

    //科学计数法
    float f3 = 3e2;//3e2 = 3 * 10 ^ 2
    float f4 = 3e-2;//3e-2 = 3* 0.1 ^ 2
     cout << "f3 =" << f3 << endl;
     cout << "f4 =" << f4 << endl;
	system("pause");
	
	return 0;
}

结果为

3.4字符型

字符型变量只占用一个字节，储存的是ASCII编码

#include <iostream>
using namespace std;

int main()
{
    //字符型创建方式
    char ch = 'a';
    cout << ch << endl;
    //创建字符型变量时，要用单引号，且内容只能有一个字符

	system("pause");
	
	return 0;
}

3.5转义字符

3.6字符串类型

两种风格

1.C风格字符串

char 变量名[] = "字符串值"

int main()
{
    char str1[] = "hello world";
    cout << str1 << endl;
    //C风格字符串要用双引号引起来
	system("pause");
	
	return 0;
}

2.C++风格

string 变量名 = “字符串值”

//在使用string函数前，需要一个头文件
#include<string>

int main()
{
    string str2 = "hello world";
    cout << str2 << endl;
	system("pause");
	
	return 0;
}

3.7布尔类型bool

作用：布尔数据类型代表真假的值

bool类型只有两个值：

  • true --- 真（本质是1）
  • false --- 假（本质上0）

bool类型只占用一个字节

int main()
{
    bool flag = true;
    cout << flag << endl;

    flag = false;
    cout << flag << endl;
	system("pause");
	
	return 0;
}

3.8数据的输入

作用：用于从键盘中获取数据

关键词：cin

语法：cin >> 变量         

int main()
{
    //1.整型
    int a = 0;
    cout << "请给a赋值" << endl;
    cin >> a;
    cout << "整型a =" << a << endl;

    //2.浮点型
    float f = 3.14f;
    cout << "请给f赋值" << endl;
    cin >> f;
    cout << "浮点型f = " << f << endl;

    //3.字符型

    //4.字符串型
    string str = "hello";
    cout << "请给str赋值" << endl;
    cin >> str;
    cout << "字符串str =" << str << endl;
    //5.bool类型


	system("pause");

	return 0;
}

四、运算符

作用：用于执行代码运算

4.1算术运算符

int main()
{
    //前置递增 先变量+1，后运算
    int a = 10;
    int b = ++a * 10;
    //a = 11
    //b = 110

    //后置递增 先运算，后变量+1
    int c = 10;
    int d = c++ * 10;
    //c = 11
    //d = 100

    system ("pause")
    return 0;
}

4.2赋值运算符

作用：用于将表达式的赋值给变量

4.3比较运算符

作用：用于表达式的比较，并返回一个真值或假值

4.4逻辑运算符

作用：用于根据表达式的值返回真值或假值

五、程序流程结构

顺序、选择、循环结构

5.1选择结构

5.1.1if语句

作用：执行满足条件的语句

  • 单行格式if语句
  • 多行格式if语句（if else）
  • 多条件的语句（if中套用if）

5.1.2三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1 ？ 表达式2 ： 表达式3

//如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

//如果表达式1的值为假，执行表达式3，并返回表达式3的结果

int main()
{
    //创建三个变量a，b，c
    //将a和b比较，将变量大的值赋给c
    
    int a = 10;
    int b = 20;
    int c = 0;
    
    c = (a > b ? a : b);
    cout << "c赋值后为：" << c << endl;
    //c = 20

    //三目运算符返回的是变量，可以继续赋值

    (a > b ? a : b) = 100
    //a = 10
    //b = 100

    system ("pause");

    return 0;
}

5.1.3 switch语句

作用：执行多条件分支语句

switch(表达式)

{

    case 结果1: 执行语句;
            break;
    case 结果2: 执行语句；
            break；
    ...
    
    default : 执行语句;
            break;

}

5.2循环语句

5.2.1 while语句

作用：满足循环条件，执行循环语句

语法：while(循环条件){循环语句}

只要循环条件为真，就执行循环语句

5.2.2 do...while循环语句

作用：满足循环条件，执行循环语句

语法：do{ 循环语句 }  while(循环条件)；

注意：与while不同的是，do...while会先执行一次循环后在判断是否符合条件

5.2.3 for循环

作用：满足循环条件，执行循环语句

语法：for(起始表达式;条件表达式;末尾循环体)   { 循环语句；}

int main()
{

    for (int i = 0; i < 10 ; i++)
    {
        cout << i << endl;
    }

    sustem("pause");

    return 0;
}

5.2.4嵌套循环

作用：在循环体中再嵌套一层循环

5.3跳转语句

5.3.1 break语句

作用：用于跳出选择结构或者循环结构

break使用时机：

  • 出现在switch条件语句中，作用是终止case并且跳出switch
  • 出现在嵌套循环语句中，作用是跳出当前的循环语句
  • 出现在嵌套循环中，跳出最近的内层循环

5.3.2 continue语句

作用：再循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下次循环

5.3.3 goto语句

作用：可以无条件跳转语句

语法：goto标记

解释：如果标记的名称存在，执行到goto语句时，会跳转到标记位置

六、数组

6.1概述

数组中的每个数据都是相同的数据类型，由连续的内存位置组成的。

6.2一维数组

6.2.1一维数组定义方式

一维数组有三种定义方式：

  • 数据类型 数组名[ 数组长度 ]；
  • 数据类型 数组名[ 数组长度 ] = { 值1，值2 ...}；
  • 数据类型 数组名[ ] = { 值1， 值2 ...};

数组元素下标是从0开始索引的

6.2.2一维数组数组名

一维数组数组名用途：

  • 可以统计整个数组在内存中的长度
  • 可以获取数组在内存中的首地址
int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
cout << "整个数组占用内存空间为:" << sizeof(arr) << endl;
cout << "每个元素占用内存空间为:" << sizeof(arr[0]) << endl;
cout << "数组中元素个数为:" << sizeof(arr) / sizeof (arr[1]) << endl;


//输出为40，4，10    



//可以通过数组名查看数组中元素地址
cout << "数组首地址为: " << (int)arr << endl;//首地址
cout << "第一个元素地址为: " << (int)arr[0] << endl;

6.3二维数组

6.3.1二维数组定义方式

二维数组有四种定义方式：

  • 数据类型   数组名[ 行数 ][ 列数 ]；
  • 数据类型   数组名[ 行数 ][ 列数 ] = {{数据1，数据2},{数据3，数据4}}；
  • 数据类型   数组名[ 行数 ][ 列数 ] = {数据1，数据2....}；
  • 数据类型   数组名[  ][ 列数 ] = {数据1，数据2...}；

6.3.2二维数组数组名称

  • 查看二维数组所占内存空间
  • 获取二维数组首地址

七、函数

7.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码。

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

7.2 函数的定义

函数的定义一般主要有五个步骤

  • 返回值类型
  • 函数名
  • 参数列表
  • 函数体语句
  • return表达式
int add(int num1, int num2)
{
    int sum = num1 + num2;

    return sum;
}

7.3函数的调用

#include<iostream>
using namespace std;

int add(int num1, int num2)
{
    int sum = num1 + num2;
    //函数定义的时候，num1和num2并没有真实数据，只是一个形式上的参数，简称形参
    return sum;
}



int main()
{
    int a = 10, b = 20;
    
    int c = add(a,b);
    //a和b成为实际参数，简称实参
    //当调用参数的时候，实参的值会传递给形参
    cout << "c = " << c << endl;
    //输出为c = 30
    system ("pause");
    
    return 0;

}

7.4 值传递

  • 所谓值传递，就是函数调用时将数值传入给形参
  • 值传递时，如果形参发生并不会影响实参
#include<iostream>
using namespace std;

void swap(int num1, int num2)
{
    cout << "交换前: " << endl;
    cout << "num1 = " << num1 << endl;
    cout << "num2 = " << num2 << endl;

    int temp = num1;
    num1 = num2;
    num2 = temp;
    cout << "交换后: " << endl;
    cout << "num1 = " << num1 << endl;
    cout << "num2 = " << num2 << endl;

}

int main()
{
    int a = 10, b = 20;

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    swap(a,b);

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    system ("pause");
    
    return 0;

}

7.5 函数的常见形式

函数常见形式有四种：

  • 无参无返
  • 有参无返
  • 无参有返
  • 有参有返
#include<iostream>
using namespace std;

//无参无返
void test1()
{
    cout << "this is test1" << endl; 
}

//有参无返
void test2(int a)
{
    cout << "this is test2 a = " << a << endl;
}

//无参有返
int test3()
{
    cout << "this is test3" << endl;
    return 1000;
}

//有参有返
int test4(int b)
{
    cout <<"this is test4 b = " << b << endl;
    return b;
}

int main()
{
    //无参无返函数调用
    test1();

    //有参无返函数调用
    test2(10);

    //无参有返函数调用
    int num1 = test3();
    cout << "num1 = " << num1 << endl;

    //有参有返函数调用
    int num2 = test4(100);
    cout << "num2 = " << num2 << endl;


    system ("pause");
    
    return 0;

}

7.6 函数的声明

作用：告诉编译器函数名称以及如何调用函数，函数的实际主体可以单独定义

  • 函数的声明可以多次，但是函数只能被定义一次
#include<iostream>
using namespace std;

int max(int a, int b);//函数声明，如若没有，在main函数之后的函数就无法使用

int main()
{

    system ("pause");
    int a = 10, b =  20;
    int c = max(a, b);
    return 0;

}

int max(int a, int b)
{
    return a > b ? a : b; 
}

7.7函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写一般分为四个步骤

  • 创建后缀名为.h的头文件
  • 创建后缀为.cpp的头文件        
  • 在头文件中写函数声明
  • 在源文件中写函数定义

*要在源文件中加入  #include "头文件名.h"

*每个文件都要加以下代码

#include<iostream>
using namespace std;

八、指针

8.1 指针的基本概念

指针的作用：可以通过指针间接访问内存

  • 内存编号时从0开始记录的，一般以十六进制数字表示
  • 可以利用指针变量保存地址

8.2 指针变量的定义和使用

指针变量定义语法：数据类型 * 变量名

#include<iostream>
using namespace std;


int main()
{
    //定义指针
    int a = 10;
    int * p;
    p = &a;
    cout << "a的地址是" << &a << endl;
    cout << "指针盘为：" << p << endl;
    //实际上指针p就是a的地址
    //使用指针
    //指针前加 * 代表解引用，找到指针指向内存中的数据
    *p = 1000;
    cout << "a = " << a << endl;
    cout << "*p = " << *p << endl;
    //a的值和*p是一致的 

    
    system ("pause");
    
    return 0;

}

8.3 空指针和野指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

int *p = NULL;
//*p不允许访问

野指针：指针变量指向非法的内存空间

int *p = (int *)0x1100
//在此之前并没有申请修改改地址的权限，所以会报错

8.4 const修饰指针

const修饰指针有三种情况：

  • const修饰指针 ---常量指针
  • const修饰变量 ---指针常量
  • const即修饰指针，又修饰常量
#include<iostream>
using namespace std;


int main()
{
    //const修饰指针
    int a = 10;
    int b = 10;
    const int *p = &a;
    //指针指向的值不可以改，指针的指向可以改
    //*p = 20(false)
    p = &b;//(true)

    //const修饰常量
    int * const p2 = &a;
    //指针的指向不可以改，指针指向的值可以改
    *p2 = 100;//(true)
    //p2 = &b(false)
    
    //const修饰指针和常量
    const int * const p3 = &a;
    //指针的指向和指针指向的值都不可以改 
    system ("pause");
    
    return 0;

}

8.5 指针和数组

作用：利用指针访问数组元素

#include<iostream>
using namespace std;


int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int *p = arr;//arr就是数组首地址
    
    cout << "利用指针访问数组第一个元素：" << *p << endl;

    p++;
    cout << "利用指针访问数组第二个元素：" << *p << endl;
    
    cout << "利用指针遍历数组:" << endl;
    int *p2 = arr;
    for (int a = 0;i < 10;i++)
    {
        cout << *p2 << endl;    
        p2++;

    }

    system ("pause");
    
    return 0;

}

8.6 指针和函数

作用：利用指针作函数参数，可以修改实参的值

#include<iostream>
using namespace std;

void swap1(int a,int b)
{
    int temp = a;
    a = b;
    b = temp;
}

void swap2(int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main()
{
    //值传递
    int a = 10, b = 20;
    swap1(a,b);
    //a和b的值并没有发生改变

    //地址传递
    swap2(&a,&b);
    //a和b值发生改变

    system ("pause");
    
    return 0;

}

九、结构体

9.1 结构体基本概念

结构体属于用户自定义的数据类型，允许用户储存不同的数据类型

9.2 结构体定义和使用

语法：struct 结构体名 { 结构体成员列表 }；

通过结构体创建变量的方式有三种

  • struct 结构体名 变量名
  • struct 结构体名 变量名 = { 1， 2...}
  • 定义结构体时顺便创建变量
#include<iostream>
using namespace std;
#include<string>

//创建学生数据类型包括：姓名，年龄，分数

struct Student
{
    string name;    
    int age;
    int score;
}s3；//第三种


int main()
{
    //通过学生类型创建具体学生
    //struct在创建时可以省略
    //第一种
    struct Student s1;
    s1.name = "张三";
    s1.age = 18;
    s1.score = 100;
    cout << "姓名：" << s1.name << "年龄：" << s1.age << "分数：" << s1.score << endl; 

    //第二种
    struct Student s2 = {"李四", 19 , 80};
    
    //第三种
    s3.name = "王五";
    s3.age = 20;
    s3.score = 60;
    
    system("pause");

    return 0;
}

9.3 结构体数组

作用：将自定义的结构体放入到数组中方便维护

语法：struct 结构体名 数组名[ 元素个数 ] = { {}， {}，.... {} }

#include<iostream>
using namespace std;
#include<string>


struct Student
{
    string name;    
    int age;
    int score;
}


int main()
{
    //创建结构体数组
    struct Student stuArray[3] = 
    {
        {"张三",18,100},
        {"李四",19,90},
        {"王五",20,80},
    }

    //给结构体数组元素赋值
    stuArray[2].name = "赵三";

    //遍历结构体数组
    for(int i = 0, i < 3, i++)
    {
        cout << "姓名：" << stuArray[i].name 
             << "年龄:" << stuArray[i].age 
             << "分数:" <<stuArray[i].score << endl; 
    }

    system("pause");

    return 0;
}

9.4结构体指针

作用：通过指针访问结构体中的成员

利用操作符 -> 可以通过结构体指针访问结构体属性

#include<iostream>
using namespace std;
#include<string>

struct Student
{
    string name;    
    int age;
    int score;
}


int main()
{
    //创建结构体变量    
    struct  Student s = {"张三", 18, 100};
    
    //通过指针指向结构体变量
    struct Student * p = &s; 

    //通过指针访问结构体变量中的数据
    cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl; 

    system("pause");

    return 0;
}

9.5 结构体嵌套结构体

作用：结构体中的成员可以使另一个结构体

#include<iostream>
using namespace std;
#include<string>

struct Student
{
    string name;    
    int age;
    int score;
}

struct teacher
{
    int id;
    string name;
    int age;
    struct Student stu;
}


int main()
{

    teacher t;
    t.id = 10000;
    t.name = "老王";
    t.age = 50;
    t.stu.name = "小王";
    t.stu.age = 20;
    t.stu.score = 100;


    system("pause");

    return 0;
}

9.6 结构体作函数参数

作用：将结构体作为参数向函数中传递

传递方式两种

  • 值传递
  • 地址传递
#include<iostream>
using namespace std;
#include<string>

//创建学生数据类型包括：姓名，年龄，分数

struct Student
{
    string name;    
    int age;
    int score;
}

//值传递（在此子函数中修改数据不会影响实参）
void printStudent1(Student s)
{
    cout << "子函数1中 姓名：" << s.name << "年龄:" << s.age << "分数：" << s.score <<     
    endl;
}

//地址传递（会改变实参）
void printStudent2(Student *p)
{
    cout << "子函数2中 姓名：" << p->name << "年龄：" << p->age << "分数：" << s.score << 
    endl;
}

int main()
{

    Student s;
    s.name = "张三";
    s.age = 18;
    s.score = 100;
    printStudent1(s);
    printStudent2(&s);
    
    system("pause");

    return 0;
}

9.7 结构体中const使用场景

作用：用const来防止误操作

#include<iostream>
using namespace std;
#include<string>

struct Student
{
    string name;    
    int age;
    int score;
}

//将函数中的形参改为指针，可以减少内存空间，而且不会复制出新的副本
void printStudent(const Student *p)
{
    //p->age = 100;加入const之后，一旦修改就会报错，可以防止我们的误操作
    cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << s.score << endl;
}

int main()
{

    Student s = {"张三", 20, 90};
    printStudent(&s);
    

    system("pause");

    return 0;
}

Tivibra
关注
  • 19
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++ 学习笔记
weixin_42098295的博客
04-29 1494
继承可以让新的类继承现有类的特性，多态通过接口的多种实现提供了函数行为的多样性，而封装则隐藏了数据的内部表示，只暴露必要的操作接口，这有助于减少系统的复杂性并提高其安全性。内存管理还涉及到堆和栈的使用，其中栈用于存储局部变量和函数调用的信息，而堆则用于动态内存分配，通常由程序员手动管理，这在处理大量数据或不确定数据大小时特别有用。在组织大型程序时，命名空间提供了避免名字冲突的方式，使得相同名字的变量或函数可以在不同的命名空间下共存，极大地增强了代码的模块化和可维护性。，用来存储数字、字符和布尔值。
c++学习笔记
Tinelines的博客
03-16 1100
1.namespace 命名空间 1.1命名空间的三种声明方式 using namespace; using namespace::func1; namespace::func1();
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
Linux C | 管道open打开方式
I_feige的博客
07-12 354
1.
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1074
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 206
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 140
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
05day--C++日期类的实现与取地址运算符的重载
weixin_73863912的博客
07-13 468
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C++客户端Qt开发——QT初识
m0_63596031的博客
07-13 833
②中的代码创建，是在堆上new出来的一块空间，当把对象改成在栈上创建，此时就可以看到运行起来的程序无法显示出helloworld，此时label对象随着构造函数的结束，就销毁了，所以应该把它交给对象树进行管理。在QT Designer中创建一个控件的时候，此时会给这个控件分配一个objectName属性，这个属性的值，要求是在界面中是唯一的，不能和别人重复。Qt的对象树模型是一种递归的结构，其中一个对象可以拥有多个子对象，而每个子对象又可以拥有自己的子对象，以此类推。坐标体系：以左上角为原点（0,0），
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
最新发布
tyfwin的博客
07-15 993
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥删除(C/C++)】
m0_70748845的博客
07-12 364
为保证数据安全性，当不需要使用该密钥时，应该删除密钥。
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 428
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 545
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值