c语言 面向对象 构造,C语言面向对象的构造

C++虚函数表实现与结构体尺寸探讨
最新推荐文章于 2023-08-23 21:54:38 发布
转载 最新推荐文章于 2023-08-23 21:54:38 发布 · 236 阅读 · 0
文章标签：

#c语言 面向对象 构造

本文详细介绍了C++中虚函数表的结构和使用，包括如何定义和初始化虚函数表，以及如何通过宏进行操作。同时，通过测试用例展示了结构体的内存布局，讨论了虚函数表的大小和成员变量的位置。此外，还对比了静态全局虚函数表和动态分配虚函数表的区别。

1.  define the structure of virtual function table

#ifndef __INTERFACE_H__

#define __INTERFACE_H__

//定义一个虚函数表名称

#define  VTBL(iname)   iname##Vtbl

//定义虚函数表结构

#define  QINTERFACE(iname) struct _##iname{/

structVTBL(iname) *pvt;/

};/

structVTBL(iname)

//定义一个虚函数表变量

#define DECLARE_VTBL(iname)      iname vt##iname;

//获取虚函数表的指针

#define GET_PVTBL(p,iname)       ( (iname *)(void *)p )->pvt

//初始化虚函数表

#define INIT_VTBL(p,iname,vt)    ( GET_PVTBL(p,iname) = (VTBL(iname) *)(void *)&vt)

//声明基类

#define DECLARE_IBASE(iname)/

int(*AddRef) (iname *);/

int(*Release)(iname *);

//下面是测试用例

typedefstruct_IList    IList;

QINTERFACE(IList)

{

DECLARE_IBASE(IList)

int(*SetActive)(IList *p,intbSet);

};

#define ILIST_AddRef(p)      GET_PVTBL( (p), IList)->AddRef( (p) )

#define ILIST_Release(p)     GET_PVTBL( (p), IList)->Release( (p) )

#define ILIST_SetActive(p,b) GET_PVTBL( (p), IList)->SetActive( (p) , (b) )

#define OBJECT(n)/

typedefstructn n;/

structn

/*################################################################################*/

//定义一个虚函数表名称

#define AEEVTBL(iname) iname##Vtbl

//定义虚函数表结构

#define AEEINTERFACE(iname)/

typedefstructAEEVTBL(iname) AEEVTBL(iname);/

structAEEVTBL(iname)

//获取虚函数表指针

#define AEEGETPVTBL(p,iname)      ( *( AEEVTBL(iname) **) (void*)p)

//初始化虚函数表

#define AEEINITVTBL(p,iname,vt)   ( AEEGETPVTBL( (p) ,iname) = (AEEVTBL(iname)*)(&vt) )

//整合了AEEINTERFACE

#define AEEINTERFACE_DEFINE(iname)/

typedefstructiname iname;/

AEEINTERFACE(iname){/

INHERIT_##iname(iname)/

};

//下面是测试用例

typedefstructTestType TestType;

#define INHERTT_TestType(TestType)/

int(*AddRef)(TestType*);/

int(*Release)(TestType*);

AEEINTERFACE(TestType)

{

INHERTT_TestType(TestType)

int(*SetActive)(TestType *p,intbSet);

};

#define ITESTTYPE_AddRef(p)         (AEEGETPVTBL(p, TestType)->AddRef(p)

#define ITESTTYPE_Release(p)        (AEEGETPVTBL(p, TestType)->Release(p)

#define ITESTTYPE_SetActive(p,b)    (AEEGETPVTBL(p, TestType)->SetActive(p,b)

#endif

#ifndef __INTERFACE_H__

#define __INTERFACE_H__

//定义一个虚函数表名称

#define VTBL(iname) iname##Vtbl

//定义虚函数表结构

#define QINTERFACE(iname) struct _##iname{/

struct VTBL(iname) *pvt;/

};/

struct VTBL(iname)

//定义一个虚函数表变量

#define DECLARE_VTBL(iname) iname vt##iname;

//获取虚函数表的指针

#define GET_PVTBL(p,iname) ( (iname *)(void *)p )->pvt

//初始化虚函数表

#define INIT_VTBL(p,iname,vt) ( GET_PVTBL(p,iname) = (VTBL(iname) *)(void *)&vt)

//声明基类

#define DECLARE_IBASE(iname)/

int (*AddRef) (iname *);/

int (*Release)(iname *);

//下面是测试用例

typedef struct _IList IList;

QINTERFACE(IList)

{

DECLARE_IBASE(IList)

int (*SetActive)(IList *p, int bSet);

};

#define ILIST_AddRef(p) GET_PVTBL( (p), IList)->AddRef( (p) )

#define ILIST_Release(p) GET_PVTBL( (p), IList)->Release( (p) )

#define ILIST_SetActive(p,b) GET_PVTBL( (p), IList)->SetActive( (p) , (b) )

#define OBJECT(n)/

typedef struct n n;/

struct n

/*################################################################################*/

//定义一个虚函数表名称

#define AEEVTBL(iname) iname##Vtbl

//定义虚函数表结构

#define AEEINTERFACE(iname)/

typedef struct AEEVTBL(iname) AEEVTBL(iname);/

struct AEEVTBL(iname)

//获取虚函数表指针

#define AEEGETPVTBL(p,iname) ( *( AEEVTBL(iname) **) (void*)p)

//初始化虚函数表

#define AEEINITVTBL(p,iname,vt) ( AEEGETPVTBL( (p) ,iname) = (AEEVTBL(iname)*)(&vt) )

//整合了AEEINTERFACE

#define AEEINTERFACE_DEFINE(iname)/

typedef struct iname iname;/

AEEINTERFACE(iname){/

INHERIT_##iname(iname)/

};

//下面是测试用例

typedef struct TestType TestType;

#define INHERTT_TestType(TestType)/

int (*AddRef)(TestType*);/

int (*Release)(TestType*);

AEEINTERFACE(TestType)

{

INHERTT_TestType(TestType)

int (*SetActive)(TestType *p, int bSet);

};

#define ITESTTYPE_AddRef(p) (AEEGETPVTBL(p, TestType)->AddRef(p)

#define ITESTTYPE_Release(p) (AEEGETPVTBL(p, TestType)->Release(p)

#define ITESTTYPE_SetActive(p,b) (AEEGETPVTBL(p, TestType)->SetActive(p,b)

#endif

2. define the structure of "class"

#include "interface.h"

#include 

usingnamespacestd;

OBJECT(List)

{

DECLARE_VTBL(IList)

intm_nRef;

intm_nCap;

intm_nInc;

};

staticintList_AddRef(IList* p)

{

printf("Call List_AddRef/n");

return0;

}

staticintList_Release(IList* p)

{

printf("Call List_Release/n");

return0;

}

staticintList_SetActive(IList* p,intb)

{

printf("Call List_SetActive/n");

return0;

}

staticconstVTBL(IList) g_ConstVtbl=

{

List_AddRef,

List_Release,

List_SetActive,

};

intTestQInterface()

{

List *pme = (List *)malloc(sizeof(List ));

if(!pme)

{

return1;

}

IList *po = (IList*)pme;

memset(pme, 0x0,sizeof(List));

INIT_VTBL(pme, IList, g_ConstVtbl);

pme->m_nRef = 1;

//virtual table size: 4 Bytes

printf("virtual table size:%d/n",sizeof(VTBL(IList)));

//object size

printf("struct size:%d/n",sizeof(List));

//member original address

printf("original address of member:0x%x/n", &pme->m_nRef);

//object and virtual original address

printf("address of pointer:0x%x/n", pme);

//the first member(int)

printf("value of m_nRef:%d/n", *(int*)((char*)(pme)+4));

printf("/n");

printf("/n");

ILIST_AddRef(po);

ILIST_Release(po);

ILIST_SetActive(po, 0);

printf("/n");

printf("/n");

free(pme);

pme = NULL;

return0;

}

structTestType

{

AEEVTBL(TestType)         *pvt;

intm_nRef;

intm_nCap;

intm_nInc;

};

staticintTestType_AddRef(TestType* p)

{

printf("Call TestType_AddRef/n");

return0;

}

staticintTestType_Release(TestType* p)

{

printf("Call TestType_Release/n");

return0;

}

staticintTestType_SetActive(TestType* p,intb)

{

printf("Call TestType_SetActive/n");

return0;

}

staticconstAEEVTBL(TestType) gTestTypeFuncTbl =

{

TestType_AddRef,

TestType_Release,

TestType_SetActive,

};

intTestAEEInterface()

{

TestType*pme = (TestType*)malloc(sizeof(TestType));

if(!pme)

{

return1;

}

AEEVTBL(TestType) *po = ( AEEVTBL(TestType)* )pme;

memset(pme, 0x0,sizeof(TestType));

AEEINITVTBL(pme, TestType, gTestTypeFuncTbl);

//pme->pvt = (AEEVTBL(TestType)*) &gTestTypeFuncTbl;

pme->m_nRef = 1;

//virtual table size: 4 Bytes

printf("virtual table size:%d/n",sizeof(AEEVTBL(TestType)));

//object size

printf("struct size:%d/n",sizeof(List));

//member original address

printf("original address of member:0x%x/n", &pme->m_nRef);

//object and virtual original address

printf("address of pointer:0x%x/n", pme);

//the first member(int)

printf("value of m_nRef:%d/n", *(int*)((char*)(pme)+4));

printf("/n");

printf("/n");

TestType_AddRef(pme);

TestType_Release(pme);

TestType_SetActive(pme,0);

printf("/n");

printf("/n");

free(pme);

pme = NULL;

return0;

}

intmain(intargc,char*argv[])

{

TestAEEInterface();

return0;

}

/*

之所以为虚函数表申请空间，应该是避免使用全局或者静态的变量来存储虚函数表

int MyFunc_New(IMyFunc **ppo)

{

//分配的内存为数据大小+虚表大小

CMyFunc *pMe = (CMyFunc *) MALLOC(sizeof(CMyFunc)+sizeof(AEEVTBL(IMyFunc)));

//使主调函数的指针指向这个对象

*ppo = (IMyFunc *)pMe;

//0初始化

MEMSET(pMe, 0, sizeof(CMyFunc)+sizeof(AEEVTBL(IMyFunc)));

//设置成员,第二个参数能计算虚表的开始地址，加的1应为偏移了整个结构大小。

//把虚函数表存储在了结构的后面[struct + vtbl]

MyFunc_Initialize(pMe, (AEEVTBL(IMyFunc)*)(pMe+1), pIModule, pIShell);

return SUCCESS;

}

//设置成员

static int MyFunc_Initialize(CMyFunc *pMe, AEEVTBL(IMyFunc) *pvt)

{

pMe->pvt = pvt;

pvt->func1 = ...;

...

} */

#include "interface.h"

#include

using namespace std;

OBJECT(List)

{

DECLARE_VTBL(IList)

int m_nRef;

int m_nCap;

int m_nInc;

};

static int List_AddRef(IList* p)

{

printf("Call List_AddRef/n");

return 0;

}

static int List_Release(IList* p)

{

printf("Call List_Release/n");

return 0;

}

static int List_SetActive(IList* p,int b)

{

printf("Call List_SetActive/n");

return 0;

}

static const VTBL(IList) g_ConstVtbl=

{

List_AddRef,

List_Release,

List_SetActive,

};

int TestQInterface()

{

List *pme = (List *)malloc(sizeof(List ));

if(!pme)

{

return 1;

}

IList *po = (IList*)pme;

memset(pme, 0x0, sizeof(List));

INIT_VTBL(pme, IList, g_ConstVtbl);

pme->m_nRef = 1;

//virtual table size: 4 Bytes

printf("virtual table size:%d/n",sizeof(VTBL(IList)));

//object size

printf("struct size:%d/n", sizeof(List));

//member original address

printf("original address of member:0x%x/n", &pme->m_nRef);

//object and virtual original address

printf("address of pointer:0x%x/n", pme);

//the first member(int)

printf("value of m_nRef:%d/n", *(int*)((char*)(pme)+4));

printf("/n");

printf("/n");

ILIST_AddRef(po);

ILIST_Release(po);

ILIST_SetActive(po, 0);

printf("/n");

printf("/n");

free(pme);

pme = NULL;

return 0;

}

struct TestType

{

AEEVTBL(TestType) *pvt;

int m_nRef;

int m_nCap;

int m_nInc;

};

static int TestType_AddRef(TestType* p)

{

printf("Call TestType_AddRef/n");

return 0;

}

static int TestType_Release(TestType* p)

{

printf("Call TestType_Release/n");

return 0;

}

static int TestType_SetActive(TestType* p,int b)

{

printf("Call TestType_SetActive/n");

return 0;

}

static const AEEVTBL(TestType) gTestTypeFuncTbl =

{

TestType_AddRef,

TestType_Release,

TestType_SetActive,

};

int TestAEEInterface()

{

TestType*pme = (TestType*)malloc(sizeof(TestType));

if(!pme)

{

return 1;

}

AEEVTBL(TestType) *po = ( AEEVTBL(TestType)* )pme;

memset(pme, 0x0, sizeof(TestType));

AEEINITVTBL(pme, TestType, gTestTypeFuncTbl);

//pme->pvt = (AEEVTBL(TestType)*) &gTestTypeFuncTbl;

pme->m_nRef = 1;

//virtual table size: 4 Bytes

printf("virtual table size:%d/n",sizeof(AEEVTBL(TestType)));

//object size

printf("struct size:%d/n", sizeof(List));

//member original address

printf("original address of member:0x%x/n", &pme->m_nRef);

//object and virtual original address

printf("address of pointer:0x%x/n", pme);

//the first member(int)

printf("value of m_nRef:%d/n", *(int*)((char*)(pme)+4));

printf("/n");

printf("/n");

TestType_AddRef(pme);

TestType_Release(pme);

TestType_SetActive(pme,0);

printf("/n");

printf("/n");

free(pme);

pme = NULL;

return 0;

}

int main(int argc, char *argv[])

{

TestAEEInterface();

return 0;

}

/*

之所以为虚函数表申请空间，应该是避免使用全局或者静态的变量来存储虚函数表

int MyFunc_New(IMyFunc **ppo)

{

//分配的内存为数据大小+虚表大小

CMyFunc *pMe = (CMyFunc *) MALLOC(sizeof(CMyFunc)+sizeof(AEEVTBL(IMyFunc)));

//使主调函数的指针指向这个对象

*ppo = (IMyFunc *)pMe;

//0初始化

MEMSET(pMe, 0, sizeof(CMyFunc)+sizeof(AEEVTBL(IMyFunc)));

//设置成员,第二个参数能计算虚表的开始地址，加的1应为偏移了整个结构大小。

//把虚函数表存储在了结构的后面[struct + vtbl]

MyFunc_Initialize(pMe, (AEEVTBL(IMyFunc)*)(pMe+1), pIModule, pIShell);

return SUCCESS;

}

//设置成员

static int MyFunc_Initialize(CMyFunc *pMe, AEEVTBL(IMyFunc) *pvt)

{

pMe->pvt = pvt;

pvt->func1 = ...;

...

} */

3. about the size of structure

1)  size of virtual function table

4 bytes

2)  size of  member variable

0xxxxx  --> original address

0xxxxx  --> virtual table          4B

0xxxxx  --> member 1

0xxxxx  --> member 2

0xxxxx  --> member 3

4. initialization of stucture.

1)  use static global virtual table.

staticconstVTBL(IList) g_ConstVtbl=

{

List_AddRef,

List_Release,

List_SetActive,

};

static const VTBL(IList) g_ConstVtbl=

{

List_AddRef,

List_Release,

List_SetActive,

};

2)  use dynamic virtual table

CMyFunc *pMe = (CMyFunc *) MALLOC(sizeof(CMyFunc)+sizeof(AEEVTBL(IMyFunc)));

0xxxxx  --> original address

0xxxxx  --> virtual table          4B

0xxxxx  --> member 1

0xxxxx  --> member 2

0xxxxx  --> member 3

0xxxxx  --> original address of virtual table

将虚函数表存储在结构后面，避免使用全局，静态的存储区

顾阑
关注
C语言面向对象的构造
王伟挺的专栏
11-20 760
1.  define the structure of virtual function table   view plaincopy to clipboardprint? #ifndef __INTERFACE_H__   #define __INTERFACE_H__       //定义一个虚函数表名称   #define  VTBL(iname)   iname#
C语言：构造对象
jk_101的博客
06-03 139
对象是 C 语言中最重要的概念。有基础的小伙伴可能会反问：“C 语言不是面向过程的吗？怎么会有对象呢？好像C++、Java之类的语言才有对象！”说的没错，但是这样问显然是未曾对 C 的灵魂——指针进行过探索。你可能听过“指针是 C 语言的灵魂所在”、“利用指针可以实现高级语言提供的操作”之类的话。那么接下就让我们乘坐“指针”的快车，在 C 语言中构造一个真正的对象。既然是构造对象，那就免不了描述对象的内部结构，即对象本身的数据结构，很显然，struct结构体就很适合，但是struct。
c语言强行面向对象之强行构造函数
Fawkess的博客
04-03 251
众所周知，c语言是一个面向对象的语言 #include <iostream> #include <cstdio> #include <iomanip> #include <string> #include <cstdlib> #include <cstring> #include <queue> #include...
C++---对象的构造
weixin_33949359的博客
05-15 171
一.对象的构造(上) Q:对象中成员变量的初始值是多少？ #include <iostream> using namespace std; class Test { private: int i; int j; public: int getI() { return i; ...
面向对象之对象的构造（上）
柳塘风淡的博客
09-06 272
前面讲了类和类的对象。那么类的成员变量初始值是多少？ 有人说是随机值，有人说是0。 下面以一个示例程序来进行分析。 #include <stdio.h> class Test { private: int i; int j; public: int GetI() {return i;} int GetJ() {return j;} }; Test ti; ...
用C语言实现面向对象编程
12-22
在C语言中实现面向对象编程是一项挑战，因为它本身并不直接支持面向对象的特性，如类、继承和封装。然而，通过巧妙地使用结构体、函数指针和宏定义，我们可以模拟这些概念。以下是对给定内容的详细解释： 1. **类的...
C语言面向对象编程
06-01
### C语言面向对象编程 #### 引言与背景 C语言作为一门历史悠久且功能强大的编程语言，在嵌入式系统、操作系统以及其他对性能有极高要求的应用领域有着广泛的应用。然而，传统的C语言是一种过程化编程语言，并没有...
C语言面向对象库.zip
最新发布
06-13
"C语言面向对象库"可能是指一些开发者为了在C语言中实现面向对象特性而创建的库或者框架。这些库通常通过宏定义、结构体和指针等C语言特性来模拟面向对象的编程模式。 面向对象编程是一种编程范式，它将数据和操作...
c语言面向对象.zip
06-13
标题“c语言面向对象.zip”暗示了这个压缩包可能包含了一些资料，可能是源代码、教程或示例，用于展示如何在C语言中实现面向对象编程的概念。尽管C++是C的扩展，增加了面向对象的特性，但有经验的开发者会用C语言...
c语言创建对象变量,C++类的定义和对象的创建
weixin_30388691的博客
05-18 429
类和对象是 C++ 的重要特性，它们使得 C++ 成为面向对象的编程语言，可以用来开发中大型项目，本节重点讲解类和对象的语法，如果你对它们的概念还不了解，请先阅读《C++类和对象的概念》。类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例(Instance)，拥有类的成员变量和成员函数。有些教程将类的成员变量称为类的...
面向对象的C语言（OOPC）之按键
acetuo的专栏
04-23 2490
概述在嵌入式系控制系统中，通常使用按键（Key）来实现人机交互，完成一些控制功能。一般地，按键在按下（KeyDown）和抬起（KeyUp）的过程中会存在10～20ms的抖动毛刺，为了获取稳定的按键信息，必须通过一定的方法来避开这段不稳定的抖动期。本文介绍了一种软件去抖动的方法，并采用面向对象的程序设计，将按键进行封装起来，对外提供统一的接口，生成单独的按键驱动文件，便于程序的移植（程序在S
C的面向对象化
qq_28938511的博客
02-13 273
1.在面向对象的语言里面，出现了类的概念。类是对特定数据的特定操作的集合体。类包含了两个范畴：数据和操作。而C语言中的struct仅仅是数据的集合，我们可以利用函数指针将struct模拟为一个包含数据和操作的”类”。 2.用C程序模拟一个最简单的“类” #define C_Class struct C_Class A { C_Class A *A_this; ...
面向对象设计中的多种分层方法
在路上...
02-23 1000
面向对象设计中的多种分层方法
面向对象程序设计c 语言,C 语言如何实现面向对象编程
weixin_42550750的博客
05-17 354
1. 具体和抽象具体：客观存在着的或在认识中反映出来的事物的整体，是具有多方面属性、特点、关系的统一；抽象：从具体事物中被抽取出来的相对独立的各个方面、属性、关系等。以 Person 为例：“pmst”，“numbbbbb”，“MM”等都是客观存在的，称之为具体；然后我们抽取共同的特性：姓名，性别，年龄和介绍自己等(当然这是极小、极小的一部分)。2. C 语言抽象的雏形先用 C 语言抽象，实现如下...
面向对象的编程思想写单片机程序——（3）学习笔记 之 程序分层、数据产生流程
嵌入式小白之进阶之路的博客
04-25 3424
文章目录系列文章目录程序分层 1、管理层 2、具体设备层 3、内核抽象（KAL）层 4、芯片抽象（CAL）层小结 程序分层 通过面向对象的编程思想来编程单片机程序，可以增强程序的可移植性，对于初入嵌入式单片机行业的小白，也更容易转向嵌入式Linux方向，对于如何抽象对于的结构体相关文章在本专栏前两篇，通过程序分层可以有效的将硬件与软件进行隔离，本文主要记录如何对程序
C语言分层设计模式简介
jy1075518049的专栏
01-24 2242
今天给大家带来单片机、嵌入式中比较常用的一种程序设计方法--分层设计模式，内核中就大量采用这种设计方式，一般对于某种硬件体系分为几层， 以一个核心层来管理，它会抽象出硬件或者个体的共性操作来进行管理，很像在用C语言实现面向对象的设计。 下面就以实际代码来简单说明。假设我们有这么一种需求，需要从某些设备读取一些数据，但是这些设备可能有51体系的，也可能有arm体系的。 那么我们应该抽象一个数据
C++ DAY3
weixin_69028524的博客
08-23 282
当类中指针指向堆区空间，需要使用析构函数将其释放，若类对象消亡后找不到指针指向堆区空间，堆区空间未释放，会造成内存泄漏class Stuint *p;public:Stu():p(new int) //在不传参的情况下，给指针成员p用堆区的空间初始化cout << "Stu无参构造" << endl;Stu(int a):p(new int(a)) //在参数为整形变量的情况下，让p指向堆区申请的空间//但是把这篇空间的内容，用传过来的整形变量初始化。
六.面向对象的嵌入式底层开发-LED（C面向对象开发）
Trstary的博客
10-26 3079
内容参考于《抽象接口技术和组件开发规范及其思想》、《面向ametal框架和接口的C编程》 六.面向对象的嵌入式底层开发 1. 场景1，LED开关实现，资源图 2. 场景2，数据收发实现，资源图
认知篇----C语言中面向对象的核心思想之经典
star_nwe的博客
05-11 469
​ ​一、前言 在嵌入式开发中，C/C++语言是使用最普及的，在C++11版本之前，它们的语法是比较相似的，只不过C++提供了面向对象的编程方式。 虽然C++语言是从C语言发展而来的，但是今天的C++已经不是当年的C语言的扩展了，从2011版本开始，更像是一门全新的语言。 ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Iz8XwuWj-1652278038882)(https://juejin.cn/ “点击并拖拽以移动”)] 那么没有想过，当初为什么要扩展出C++？C语
C语言面向对象编程实践指南
面向对象编程（Object Oriented Programming，简称OOP）是一种计算机编程架构思想，其主要目标是让软件的设计与构造更加模块化、易于理解、可复用，并具有更高的可维护性。在C语言中实现面向对象编程并不是语言本身...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值