【C语言学习】深入理解指针（5）

最新推荐文章于 2024-07-05 22:49:45 发布
最新推荐文章于 2024-07-05 22:49:45 发布
阅读量58 收藏
点赞数
分类专栏： C语言学习 文章标签： c语言 学习 算法 开发语言 c# 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/embrace99/article/details/133053304
版权

1. sizeof和strlen的对比

之前我们简单介绍了sizeof和strlen的一些区别，今天我们更深入讲解他们的不同。

1.1 sizeof

我们先来回顾一下sizeof的知识， sizeof 计算的是变量所占内存空间的大小，单位是字节，如果操作数是类型的话，计算的是使用类型创建的变量所占内存空间的大小。
sizeof不关心内存中存放的数据是什么，例如：

//sizeof计算变量
//size_t其实专门是设计给sizeof的，表示sizeof的返回值类型

int main()
{
	int a = 0;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));
	printf("%u\n", sizeof(a));
	return 0;
}

运行结果：

那strlen又是怎样的情况呢？

1.2 strlen

strlen是一个标准的C语言库函数，其在cplusplus中的原型如下：

strlen函数统计的是从参数 str 这个地址开始向后，\0 之前字符串中字符的个数。所以strlen 函数会⼀直向后找 \0 字符，直到找到为止，所以可能存在越界访问的情况。
与sizeof相比，strlen是关心内存中存放的数据是什么，没有\0，它会疯的！

int main()
{
	//char arr[] = "abcdef";
	char arr[] = { 'a', 'b', 'c' };
	printf("%d\n", strlen(arr));
	return 0;
}

运行结果：

调试代码：

通过调试出内存窗口，我们可以发现，要找到 ‘\0’，strlen要在字符 ‘c’ 还需要找12个字符！
总结：sizeof和strlen的细致对比
sizeof
1.sizeof是操作符；
2.sizeof计算操作数所占内存的大小，单位是字节；
3. sizeof不关注内存中存放的是什么数据。
strlen
1.strlen是库函数，使用时需要包含头文件 <string.h>；
2.srtlen是求字符串长度，统计的是 ‘\0’ 之前字符的个数；
3.strlen关注的是内存中是否有 ‘\0’，如果没有 ‘\0’，就会持续往后找，可能会导致越界。

讲解完以上内容，我们再来看一段有趣的代码：

int main()
{
	short s = 10;//占2个字节
	int i = 2;//占4个字节
	int n = sizeof(s = i + 4);
	printf("%d\n", n);
	printf("%d\n", s);

运行结果：

为什么会是上面这种结果呢？
别着急，我们慢慢来解释：
1.首先，sizeof 后面的表达式会发生截断，放到s中去，结果仍由s说了算 → 2个字节。
2.其次，sizeof 的操作数是一个表达式，表达式是不参与计算的，所以s仍为10。
为什么表达式不参与计算？
代码编译生成可执行程序，先编译再计算，编译过程执行sizeof，sizeof(s = i + 4) = sizeof(short)，相当于跳过了s = i + 4。

通过上面这个例子我们可以得出结论：
表达式存在两个属性：1. 值属性； 2. 类型属性

2. 部分数组和指针笔试题解析

2.1 数组运算题解析

2.1.1 一维数组

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int a[] = { 1, 2, 3, 4 };
	printf("%d\n", sizeof(a));//数组a的大小

	printf("%d\n", sizeof(a + 0));//数组名a并没有单独放在sizeof()内部，也没有&;
	//所以a就是数组首元素的地址，是地址就是4/8个字节
	
	printf("%d\n", sizeof(*a));//a就是首元素的地址, a = &a[0]
	//*a就是第一个元素，也就是a[0]，大小就是4个字节

	printf("%d\n", sizeof(a + 1));//4或8—a就是数组首元素的地址（&a[0]—int*），a+1-->&a[1]
	//a+1就是第二个元素的地址

	printf("%d\n", sizeof(a[1]));//4—计算第二个元素的大小，单位是字节

	printf("%d\n", sizeof(&a));//&a—取出的是数组的地址，但是数据的地址也是地址，地址的大小就是4/8个字节
	
	printf("%d\n", sizeof(*&a));//第一种解读：相当于printf("%d\n", sizeof(a))—16
	//第二种解读：
	//&a—int (*p)[4]
	//*p 访问一个数组的大小
	//p+1 跳过一个数组的大小

	printf("%d\n", sizeof(&a + 1));//跳过一个数组后的地址，是地址就是4/8个字节

	printf("%d\n", sizeof(&a[0]));//首元素的地址，4/8

	printf("%d\n", sizeof(&a[0] + 1));//第二个元素的地址
	//&a[1]
	//&a[0] - int*
	return 0;
}

运行结果：

2.1.2 字符数组

（一）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main()
{
	char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	printf("%d\n", sizeof(arr));//6

	printf("%d\n", sizeof(arr + 0));//arr是数组首元素的地址，arr+0还是首元素的地址，地址大小就是4/8个字节
	
	printf("%d\n", sizeof(*arr));//arr还是首元素的地址，*arr就是首元素，就占1个字节
	
	printf("%d\n", sizeof(arr[1]));//arr[1]就是数组的第二个元素，大小是1个字节
	
	printf("%d\n", sizeof(&arr));//&arr是数组的地址，数组的地址也是地址，大小就是4/8个字节
	
	printf("%d\n", sizeof(&arr + 1));//跳过一个数组后的地址，是地址就是4/8个字节
	
	printf("%d\n", sizeof(&arr[0] + 1));//第二个元素的地址

	return 0;
}

运行结果：

（二）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main()
{
	char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	printf("%d\n", strlen(arr));//随机值，因为数组中没有明确给出\0

	printf("%d\n", strlen(arr + 0));//随机值
	
	printf("%d\n", strlen(*arr));//*arr ——> 'a' ——> 97,非法访问
	
	printf("%d\n", strlen(arr[1]));//非法访问
	
	printf("%d\n", strlen(&arr));//随机值
	//&arr                const char*
	//char (*p)[6]        const char*
	
	printf("%d\n", strlen(&arr + 1));//随机值（与前面的随机值差6）
	
	printf("%d\n", strlen(&arr[0] + 1));//随机值

	return 0;
}

（三）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main()
{
	char arr[] = "abcdef";
	//[a b c d e f \0]
	
	printf("%d\n", sizeof(arr));//7
	
	printf("%d\n", sizeof(arr+0));//arr是数组首元素的地址，arr+0还是首元素的地址，地址大小就是4/8个字节
	
	printf("%d\n", sizeof(*arr));//arr表示首元素的地址，*arr就是首元素，大小是1个字节
	
	printf("%d\n", sizeof(arr[1]));//arr[1]就是数组第二个元素，大小也是1个字节
	
	printf("%d\n", sizeof(&arr));//&arr是数组的地址，大小是4/8个字节
	
	printf("%d\n", sizeof(&arr+1));//跳过1个数组后的地址，是地址就是4/8个字节
	
	printf("%d\n", sizeof(&arr[0]+1));//第二个元素的地址，大小是4/8个字节
	
	return 0;
}

运行结果：

（四）


int main()
{
	char arr[] = "abcdef";
	//[a b c d e f \0]
	
	printf("%d\n", strlen(arr));//6 arr是首元素的地址
	
	printf("%d\n", strlen(arr+0));//6 arr + 0也是首元素的地址
	
	printf("%d\n", strlen(*arr));//error - 非法访问
	
	printf("%d\n", strlen(arr[1]));//error - 非法访问
	
	printf("%d\n", strlen(&arr));//6 &arr是数组的地址，但是这个地址也是指向数组的起始位置
	
	printf("%d\n", strlen(&arr+1));//跳过整个数组后的地址，从这里开始找\0，就是随机值
	
	printf("%d\n", strlen(&arr[0]+1));//第二个元素的地址，长度是5
	
	return 0;
}

运行结果：

（五）

int main()
{
	char* p = "abcdef";
	//[a b c d e f \0]

	printf("%d\n", sizeof(p));//p是一个指针变量，大小是4/8个字节
	
	printf("%d\n", sizeof(p+1));//第二个元素b的地址，大小是4/8个字节
	
	printf("%d\n", sizeof(*p));//*p指向第一个元素a，大小是1个字节
	
	printf("%d\n", sizeof(p[0]));//p[0] ——> *(p + 0)，其实就是字符串中的首字符，大小是1个字节
	//字符串可以看成是一个数组，p是数组首元素a的地址，p[0]其实就是访问数组中的元素a，大小是1个字节
	
	printf("%d\n", sizeof(&p));//&p是p的地址，是地址大小就是4/8个字节
	
	printf("%d\n", sizeof(&p+1));//&p + 1也是地址，&p + 1跳过p变量后的地址
	
	printf("%d\n", sizeof(&p[0]+1));//4/8 - 第二个元素b的地址
	
	return 0;
}

运行结果：

（六）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	char *p = "abcdef";

	printf("%d\n", strlen(p));//6 - 字符串中有\0，从p中存放的是a的地址，从a的地址开始向后访问

	printf("%d\n", strlen(p + 1));//5 - 从b的地址开始向后访问

	printf("%d\n", strlen(*p));//error - 非法访问

	printf("%d\n", strlen(p[0]));//error - 非法访问

	printf("%d\n", strlen(&p));//随机值，&p是p的地址，从p所占空间的起始位置查找

	printf("%d\n", strlen(&p + 1));//随机值

	printf("%d\n", strlen(&p[0] + 1));//5

	return 0;
}

运行结果：

2.1.2 二维数组

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <assert.h>

int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//计算的是整个二维数组的大小，单位是字节—48

	printf("%d\n", sizeof(a[0][0]));//a[0][0]-第一个元素的大小，大小是4个字节

	printf("%d\n", sizeof(a[0]));//16 - a[0]其实是第一行的数组名，这里第一行的数组名单独放在sizeof内部了，计算的是第一行的大小

	printf("%d\n", sizeof(a[0] + 1));//
	//a[0]是第一行这个数组的数组名，但是数组名并没有单独放在sizeof内部，所以数组名表示数组首元素的地址，也就是a[0][0]的地址，a[0] + 1是第一行第二个元素（a[0][1]）的地址

	printf("%d\n", sizeof(*(a[0] + 1)));//a[0] + 1是第一行第二个元素（a[0][1]）的地址
	//*(a[0] + 1)是第一行第二个元素，大小是4个字节

	printf("%d\n", sizeof(a + 1));//a是二维数组的数组名，没有单独放在sizeof的内部，所以a就是数组首元素的地址，也就是第一行的地址
	//a + 1就是第二行的地址
	//a -- int (*)[4]
	//a + 1 -- int (*)[4]

	printf("%d\n", sizeof(*(a + 1)));//16 --> *(a + 1) == a[1]


	printf("%d\n", sizeof(&a[0] + 1));//第二行的地址，是地址大小就是4/8个字节
	//a[0]是第一行的数组名，&a[0]取出的是第一行的地址，&a[0] + 1得到的就是第二行的地址

	printf("%d\n", sizeof(*(&a[0] + 1)));//16

	printf("%d\n", sizeof(*a));//16—数组名a就是数组首元素的地址，也就是第一行的地址，*a就是第一行的大小
	//*a == *(a + 0) == a[0]

	printf("%d\n", sizeof(a[3]));//16
	//arr[3] == arr[0]
	return 0;
}

运行结果：

通过上述实例，我们可以先总结一波：
1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
3.除了以上两种情况以外，其余所有的数组名都表示首元素的地址。

2.2 指针运算笔试题解析

（一）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int *ptr = (int *)(&a + 1);
	printf("%d,%d", *(a + 1), *(ptr - 1));
	return 0;
}

运行结果：

代码分析：

（二）
在X86环境下，假设结构体的大小是20个字节，下列程序输出的结果是啥？

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct Test
{
	int Num;
	char *pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p = (struct Test*)0x100000;

int main()
{
	printf("%p\n", p + 0x1);//0x1 == 1
	//0x100014        不是0x100020，需要转换成16进制数字

	printf("%p\n", (unsigned long)p + 0x1);//p被强制类型转换成整型—0x100001

	printf("%p\n", (unsigned int*)p + 0x1);//0x100004

	return 0;
}

运行结果：

（三）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };//逗号表达式从左向右依次计算，但是整个表达式的结果是最后一个表达式的结果。
	//1 3
	//5 0
	//0 0
	int *p;
	p = a[0];
	printf("%d\n", p[0]);
	return 0;
}

运行结果：

代码解析：

（四）重点！！！

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int a[5][5];
	int(*p)[4];
	p = a;
	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
	return 0;
}

运行结果：

代码解析：

p[4][2]可以看成是(p + 4)[2]，两个指针相减得到的是两个之间的元素个数，即4。但是由于&p[4][2]的地址小于&a[4][2]，所以结果为-4。
而-4在内存中是以补码的形式存放的：
1000 0000 0000 0000 0000 0000 0000 0100 — 原码
1111 1111 1111 1111 1111 1111 1111 1011 — 反码
1111 1111 1111 1111 1111 1111 1111 1100 — 补码
F F F F F F F C — 地址
（五）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int *ptr1 = (int *)(&aa + 1);
	int *ptr2 = (int *)(*(aa + 1));
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}

运行结果：

代码解析：

（六）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	char *a[] = { "work", "at", "alibaba" };
	char**pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

运行结果：

代码解析：

（七）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	char* c[] = { "ENTER", "NEW", "POINT", "FIRST" };
	char** cp[] = { c + 3, c + 2, c + 1, c };
	char*** cpp = cp;
	printf("%s\n", **++cpp);
	printf("%s\n", *--*++cpp + 3);
	printf("%s\n", *cpp[-2] + 3);
	printf("%s\n", cpp[-1][-1] + 1);
	return 0;
}

运行结果：

代码解析：

**++cpp

cpp指向 c + 3，++cpp后指向 c + 2，解引用两次后指向"POINT"。

*- -*++cpp + 3

cpp经过上述操作指向 c + 2，经过++cpp后，指向 c + 1，解引用再经过- -cpp，指向c，解引用两次后指向"ENTER"，加3后指向"ER"。

*cpp[-2] + 3

cpp[-2]等价于 *(cpp - 2)，刚才我们的cpp指向 c + 1，减2后指向 c + 3 ，解引用后指向c[3]，再次解引用后指向"FIRST"，加3后指向"ST"。

cpp[-1][-1] + 1

cpp[-1][-1]我们可以看作是*(*(cpp - 1) - 1)，刚才cpp指向 c + 3，减1后指向 c + 2，解引用后指向c[2]，减1之后指向c[1]，c[1]解引用后指向"NEW"，加1后指向"EW"。

好了，以上就是本期博客的全部内容了，这也是指针部分最后一期内容，看在我肝这么久的份上，还请小伙伴们多多支持。另外，由于工作原因，没办法做到像以前那样频繁更新，还请小伙伴们理解🤝，让我们一起在代码的世界里遨游。

embrace99
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解C语言指针
08-25
深入理解C语言指针 C语言指针是C语言的核心概念之一，正确理解指针是C语言编程的关键。指针是C语言中的一种数据类型，它指向内存空间的某个地址，占有内存空间。学习指针需要正确理解指针的概念和使用。 指针的...
深入理解C语言指针和结构体
06-12
深入理解这两个概念不仅能提升C语言编程能力，也能为学习其他编程语言打下坚实的基础。通过实际编程练习和分析代码，我们可以更好地掌握这些知识，并应用到实际项目中。在编程过程中，不断实践和反思是提升技能的...
C语言：深入理解指针(4)
weixin_51142926的博客
12-16 3620
函数指针是将函数的地址取出来，再通过函数地址去调用，那为什么不直接用函数名调用呢？？原因是因为函数指针可以用来实现回调函数，而回调函数有自己的应用场景。如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数 时，被调⽤的函数就是回调函数。以上这段代码中，我们可以把调用的函数地址以参数的形式传去，用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实就是使用的回调函数功能。前面学习的冒泡排序，只能排序整形数据，那我们如何完成其他数据的排序呢？就得用到qsort。
c语言指针深入理解
moran114的博客
07-03 1152
指针是c语言中较难理解的知识点了，也非常重要，今天我们就来一起深入理解指针吧🌞🌞🌞
c语言指针（深入了解指针）
热门推荐
小马同学的博客
11-12 2万+
由浅到深全面的了解指针（小马带你拿下指针的学习）
C语言：深入理解指针(1)
weixin_51142926的博客
12-11 4839
大家好，今天来给大家分享一下我对指针的理解 学习内存之前，引用一下生活中的一个案例 假设你知道你的一个朋友住在一个小区，这个小区有10栋楼，每栋楼10个楼层，每个楼层又有10个房间，你想找到他就得挨个挨个房间去找，这样效率是非常低的，但如果根据这些楼层和楼层房间的情况，给每个房间编上号，比如说1号楼1楼第1个房间，编上1#101，以此类推，那么你的朋友得到了房间号并告诉你，你就能迅速地根据信息找到他所在的房间。 所以在生活中，一些小区、酒店通过设置了房间号，方便客人快速找
C语言：深入理解指针(3)
weixin_51142926的博客
12-15 3790
通过深入理解指针（1）和深入理解指针（2），我们对指针有了一个初步的了解，学会了一级指针、二级指针、指针数组……而深入理解指针（3），主要是为了学习不同数据类型的指针变量。
C语言—深入理解指针（5）
l1894的博客
06-02 555
在学习操作符的时候，我们学习了 sizeof，，如果操作数是的话，计算的是所占内存空间的大小。sizeof 只关注占用内容空间的大小，不在乎内存中存放什么数据。
【c语言】深入理解指针（2）
weixin_58252863的博客
02-07 2935
可以利用字符指针存放字符数组来间接存放字符串。那我们可不可以直接给字符指针存放字符串呢？我们来看一下结果：可以看到是可以直接给字符指针存放字符串，其实指针仅仅存放了字符串首字母的地址，%s会根据这个首字母的地址依次打印字符，当遇到空字符‘\0’则会停止打印，从而打印出了完整的字符串。字符指针存放字符数组的字符串可修改，而存放字符串字面量不可修改，因为。
【C语言】深入理解指针
2301_76771985的博客
02-08 4824
他的四个参数分别是要进行排序的数组base的首地址，base数组的元素个数，每个元素的大小，以及一个函数指针，这个函数指针指向了一个函数，这个函数的参数是两个void*类型的指针，返回类型是int，要求这个函数能够比较参数（这个函数的参数是两个指针）指向的两个元素的大小，规定如果elem1指向的元素比elem2指向的元素大，那这个函数就返回一个大于零的数，反之就返回一个小于零的数，如果elem1和elem2指向的元素一样大，就返回0。指向的元素是int [10]类型的，存放的内容是arr的地址。
深入理解C语言-深入理解指针
cj5785
04-02 2166
关于指针，其是C语言的重点，C语言学的好坏，其实就是指针学的好坏。其实指针并不复杂，学习指针，要正确的理解指针。 指针是一种数据类型 指针也是一种变量，占有内存空间，用来保存内存地址 指针就是告诉编译器，开辟4个字节的存储空间（32位系统），无论是几级指针都是一样的 *p操作内存 在指针声明时，* 号表示所声明的变量为指针 在指针使用时，* 号表示操作指针所指向的内存空间中的值 *p相当于通过地址...
深入理解C语言指针的奥秘.doc
07-13
深入理解C语言指针的奥秘.doc 深入理解C语言指针的奥秘.doc 深入理解C语言指针的奥秘.doc 深入理解C语言指针的奥秘.doc 深入理解C语言指针的奥秘.doc 深入理解C语言指针的奥秘.doc 深入理解C语言指针的奥秘.doc 深入...
深入理解C语言指针.pdf
09-30
"深入理解C语言指针" 在C语言中，指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存...
深入理解C语言指针及占据内存空间
08-25
深入理解C语言指针及占据内存空间 C语言指针及占据内存空间是计算机编程中的一项重要概念，了解指针和内存空间的相关知识对于编程的深入理解和应用至关重要。本文将深入探讨C语言指针及占据内存空间的相关知识，...
C语言 | Leetcode C语言题解之第205题同构字符串
m0_59237910的博客
06-30 312
C语言 | Leetcode C语言题解之第205题同构字符串
【学习笔记】Redis学习笔记——第4章 字典
Lchen_kk的博客
06-30 236
因为对hash太熟悉了(java中的HashMap)，所以忽略了前面几段对于hash基础的讲解。
昇思MindSpore学习笔记2-01 LLM原理和实践 --基于 MindSpore 实现 BERT 对话情绪识别
muren的专栏
07-02 972
通过识别BERT对话情绪状态的实例，展现在昇思MindSpore AI框架中大语言模型的原理和实际使用方法、步骤。
JMH320【亲测】【御剑九歌】唯美仙侠手游御剑九歌+WIN学习手工端+视频教程+开服清档+运营后台+授权GM物品充值后台
最新发布
m0_71430218的博客
07-05 296
JMH320【亲测】【御剑九歌】唯美仙侠手游御剑九歌+WIN学习手工端+视频教程+开服清档+运营后台+授权GM物品充值后台
计算机 C语言 讲师 第7章 指针类型
03-08
计算机 C语言 讲师 第7章 指针类型

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值