com技术内幕--读书笔记（8_1）

最新推荐文章于 2013-03-24 00:25:07 发布
最新推荐文章于 2013-03-24 00:25:07 发布
阅读量1.9k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： COM 文章标签： 读书 null interface delete class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/simeone18/article/details/7224773
本文是关于COM技术的读书笔记，重点探讨了COM如何支持接口继承而不支持实现继承，以保持组件独立性。同时，介绍了在C++中如何通过包容和聚合在接口级别改造组件。包容是一种外部组件使用内部组件接口的技术，允许外部组件在不修改内部组件的情况下扩展其功能。文中通过代码示例展示了包容的实现过程及其主要用途。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第8章


“实现继承”，指的是继承基类代码或实现，“接口继承”，指的是继承基类类型或接口。 COM支持的继承是接口继承，不支持实现继承。实现继承会导致一个对象的实现同另外一个对象实现关联起来，当基类修改后，派生类也就必须被修改，甚至客户端的程序也需要修改，这显然有悖于COM组件编程的基本思想。

在C++中，对类的改造用包容和继承来实现的。在COM中，对组件的改造是使用包容和聚合来实现的，包容和聚合都是在接口级实现的。


包容

包容，是一个组件使用另外一个组件的技术，分别成为外部组件和内部组件。

包容的情况下，外部组件包含指向内部组件接口的指针，外部组件只是内部组件的一个客户。外部组件使用内部组件的接口来实现它自己的接口，并且可以在接口的实现函数加上它对内部组件接口实现的修改。

组件的包容类似c++的包容。


示意图如下



包容的实现

在下面的例子中，组件1（Component1）是一个实现了IX和IY接口的外部组件，它复用了组件2（组件1包容的内部组件）对IY接口的实现。源码与第七章的没多大差别，只是在组建1中加入了一个Init()的函数，用来创建组件2中的IY接口指针。组件2是一个典型的COM组件。当客户向Component1请求IY接口时，Component1将返回其IY接口的一个指针。当客户调用Component1中的IY接口时，Component1通过如下的代码将把这些调用请求转发给Component2。

void __stdcall CA::Fy()
{
    m_pIy->Fy();
}
当Component1将自己销毁时，它将调用m_pIy上的Release，以使Component2将自己从内存释放。

Component1的类厂所做的修改，只是在类厂创建好Component1之后加上对Component1的Init()的调用，用来创建组件2。


本章代码

组件2部分：cmpnt2.cpp

//
//cmpnt2.cpp
//use: cl /LD cmpnt2.cpp guids.cpp registry.cpp cmpnt2.def uuid.lib ole32.lib advapi32.lib    
//     regsvr32 /s cmpnt2.dll
//     ole32.lib COMLIBRARY advapi32.lib REGISTER
#include <objbase.h>
#include "iface.h"
#include "registry.h"
#include <iostream>
#include <string>
using namespace std;

//global function
//
static HMODULE g_hModule = NULL;  //COMPONENT2 MODULE HANDLE
static long g_lComponent = 0;     //COMPONENT2 COUNT
static long g_lServerLocks = 0;   //CFactory COUNT

//Friendly Name
const char g_szFriendlyName[]
   = "Inside COM, Chapter 8 Example 1, Component 2";

//Version-independent ProgID
const char g_szVerIndProgID[] = "InsideCOM.chap08.ex1.cmpnt2";

//ProgID
const char g_szProgID[] = "InsideCOM.chap08.ex1.cmpnt2.1";

//trace function
void trace(string msg)
{
	cout<<msg<<endl;
}

////////////////////////////////////////////
//class CB
//
class CB : public IY
{
public:
	virtual HRESULT __stdcall QueryInterface(const IID& iid, void **ppv);
	virtual ULONG   __stdcall AddRef();
	virtual ULONG   __stdcall Release();
	virtual void    __stdcall Fy() {cout<<"CB::Fy"<<endl;}

	CB();
	~CB();

private:
	long m_cRef;
};

CB::CB():m_cRef(1)
{
	InterlockedIncrement(&g_lComponent);
}

CB::~CB()
{
	trace("component2 destroy self");
	InterlockedDecrement(&g_lComponent);
}

ULONG __stdcall CB::AddRef()
{
	return InterlockedIncrement(&m_cRef);
}

ULONG __stdcall CB::Release()
{
	if(InterlockedDecrement(&m_cRef) == 0)
	{	
		delete this;
		return 0;
	}
	return m_cRef;
}

HRESULT __stdcall CB::QueryInterface(const IID& iid, void **ppv)
{
	if(iid == IID_IUnknown)
	{
		*ppv = static_cast<IY*>(this);
	}
	else if(iid == IID_IY)
	{
		*ppv = static_cast<IY*>(this);
	}
	else
	{
		*ppv = NULL;
		return E_NOINTERFACE;
	}
	reinterpret_cast<IUnknown*>(*ppv)->AddRef();
	return S_OK;
}

/////////////////////////////////////////////
//class factory
//
class CFactory : public IClassFactory
{
public:
	//interface iunknown
	virtual HRESULT __stdcall QueryInterface(const IID& iid, void **ppv);
	virtual ULONG   __stdcall AddRef();
	virtual ULONG   __stdcall Release();
	//interface iclassfactory
	virtual HRESULT __stdcall CreateInstance(IUnknown *pIUnknownOuter, const IID& iid, void **ppv);
	virtual HRESULT __stdcall LockServer(BOOL bLock);

	CFactory();
	~CFactory();
private:
	long m_cRef;
};

CFactory::CFactory():m_cRef(1)
{
}

CFactory::~CFactory()
{
	trace("component2 cfactory : destroy self");
}

HRESULT __stdcall CFactory::QueryInterface(const IID& iid, void **ppv)
{
	if(iid == IID_IUnknown || iid == IID_IClassFactory)
	{
		*ppv = static_cast<IClassFactory*>(this);
	}
	else
	{
		*ppv = NULL;
		return E_NOINTERFACE;
	}
	reinterpret_cast<IUnknown*>(*ppv)->AddRef();
	return S_OK;
}

ULONG __stdcall CFactory::AddRef()
{
	return InterlockedIncrement(&m_cRef);
}

ULONG __stdcall CFactory::Release()
{
	if(InterlockedDecrement(&m_cRef) == 0)
	{
		delete this;
		return 0;
	}
	return m_cRef;
}

//CreateInstance
HRESULT __stdcall CFactory::CreateInstance(IUnknown *pIUnknownOuter, const IID& iid, void **ppv)
{
	if(pIUnknownOuter != NULL)
	{
		trace("no aggregation");
		return CLASS_E_NOAGGREGATION;
	}
	//Create Compnent2
	CB *pB = new CB();
	if(pB == NULL)
	{
		return E_OUTOFMEMORY;
	}
	//Get Request interface
	HRESULT hr = pB->QueryInterface(iid, ppv);

	//Release IUnknown interface
	pB->Release();
	return hr;
}

HRESULT __stdcall CFactory::LockServer(BOOL bLock)
{
	if(bLock == TRUE)
	{
		InterlockedIncrement(&g_lServerLocks);
	}	
	else
	{
		InterlockedDecrement(&g_lServerLocks);
	}
	return S_OK;
}

////////////////////////////////////////
//export functions
//
//Get Interface IClassFactory
STDAPI DllGetClassObject(const CLSID& clsid, const IID& iid, void **ppv)
{
	if(clsid != CLSID_Component2)
		return CLASS_E_CLASSNOTAVAILABLE;

	CFactory *pFactory = new CFactory();
	if(pFactory == NULL)
	{
		return E_OUTOFMEMORY;
	}
	HRESULT hr = pFactory->QueryInterface(iid, ppv);
	pFactory->Release();
	return hr;
}

STDAPI DllCanUnloadNow()
{
	if(g_lComponent == 0 && g_lServerLocks == 0)
		return S_OK;
	else
		return S_FALSE;
}

STDAPI DllRegisterServer()
{
	return RegisterServer(g_hModule,
						  CLSID_Component2,
						  g_szFriendlyName,
						  g_szVerIndProgID,
						  g_szProgID);
}

STDAPI DllUnRegisterServer()
{
	return UnregisterServer(CLSID_Component2,
							g_szVerIndProgID,
							g_szProgID);
}

BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpvReserved)
{
	if(dwReason == DLL_PROCESS_ATTACH)
	{
		g_hModule = hModule;
	}
	return TRUE;
}

cmpnt2.def 

LIBRARY      cmpnt2.dll
DESCRIPTION	 'Chapter08 Component2'
EXPORTS      DllGetClassObject    @2   private
             DllCanUnloadNow      @3     private
		     DllRegisterServer    @4   private
		     DllUnRegisterServer  @5 private

组件1部分：cmpnt1.
//
//cmpnt1.cpp
//use: cl /LD cmpnt1.cpp guids.cpp registry.cpp cmpnt2.def uuid.lib ole32.lib advapi32.lib    
//     regsvr32 /s cmpnt1.dll
//     ole32.lib COMLIBRARY advapi32.lib REGISTER
#include <objbase.h>
#include "iface.h"
#include "registry.h"
#include <iostream>
#include <string>
using namespace std;

//global function
//
static HMODULE g_hModule = NULL;  //COMPONENT1 MODULE HANDLE
static long g_lComponent = 0;     //COMPONENT1 COUNT
static long g_lServerLocks = 0;   //CFactory COUNT

//Friendly Name
const char g_szFriendlyName[]
   = "Inside COM, Chapter 8 Example 1, Component 1";

//Version-independent ProgID
const char g_szVerIndProgID[] = "InsideCOM.chap08.ex1.cmpnt1";

//ProgID
const char g_szProgID[] = "InsideCOM.chap08.ex1.cmpnt1.1";

//trace function
void trace(string msg)
{
	cout<<msg<<endl;
}

////////////////////////////////////////////
//class CA
//
class CA : public IX, public IY
{
public:
	virtual HRESULT __stdcall QueryInterface(const IID& iid, void **ppv);
	virtual ULONG   __stdcall AddRef();
	virtual ULONG   __stdcall Release();
	virtual void    __stdcall Fx() {cout<<"CA::Fx"<<endl;}
	virtual void    __stdcall Fy();

	CA();
	~CA();

	HRESULT __stdcall Init();
private:
	//pointer to the contained components's IY interface
	IY  *m_pIy;
	long m_cRef;
};

CA::CA():m_cRef(1)
{
	InterlockedIncrement(&g_lComponent);
	m_pIy = NULL;
}

CA::~CA()
{
	trace("component1 destroy self");
	InterlockedDecrement(&g_lComponent);
	if(m_pIy != NULL)
	{
		m_pIy->Release();
	}
}

ULONG __stdcall CA::AddRef()
{
	return InterlockedIncrement(&m_cRef);
}

ULONG __stdcall CA::Release()
{
	if(InterlockedDecrement(&m_cRef) == 0)
	{	
		delete this;
		return 0;
	}
	return m_cRef;
}

HRESULT __stdcall CA::QueryInterface(const IID& iid, void **ppv)
{
	if(iid == IID_IUnknown)
	{
		*ppv = static_cast<IX*>(this);
	}
	else if(iid == IID_IX)
	{
		*ppv = static_cast<IX*>(this);
	}
	else if(iid == IID_IY)
	{
		*ppv = static_cast<IY*>(this);
	}
	else
	{
		*ppv = NULL;
		return E_NOINTERFACE;
	}
	reinterpret_cast<IUnknown*>(*ppv)->AddRef();
	return S_OK;
}

void __stdcall CA::Fy()
{
	m_pIy->Fy();
}

HRESULT __stdcall CA::Init()
{
	HRESULT hr = CoCreateInstance(CLSID_Component2, 
								  NULL,
								  CLSCTX_INPROC_SERVER,
								  IID_IY,
								  (void**)&m_pIy);
	if(FAILED(hr))
	{
		trace("couldn't create contained component");
		return E_FAIL;
	}
	else
	{
		return S_OK;
	}
}

/////////////////////////////////////////////
//class factory
//
class CFactory : public IClassFactory
{
public:
	//interface iunknown
	virtual HRESULT __stdcall QueryInterface(const IID& iid, void **ppv);
	virtual ULONG   __stdcall AddRef();
	virtual ULONG   __stdcall Release();
	//interface iclassfactory
	virtual HRESULT __stdcall CreateInstance(IUnknown *pIUnknownOuter, const IID& iid, void **ppv);
	virtual HRESULT __stdcall LockServer(BOOL bLock);

	CFactory();
	~CFactory();
private:
	long m_cRef;
};

CFactory::CFactory():m_cRef(1)
{
}

CFactory::~CFactory()
{
	trace("component1 cfactory : destroy self");
}

HRESULT __stdcall CFactory::QueryInterface(const IID& iid, void **ppv)
{
	if(iid == IID_IUnknown || iid == IID_IClassFactory)
	{
		*ppv = static_cast<IClassFactory*>(this);
	}
	else
	{
		*ppv = NULL;
		return E_NOINTERFACE;
	}
	reinterpret_cast<IUnknown*>(*ppv)->AddRef();
	return S_OK;
}

ULONG __stdcall CFactory::AddRef()
{
	return InterlockedIncrement(&m_cRef);
}

ULONG __stdcall CFactory::Release()
{
	if(InterlockedDecrement(&m_cRef) == 0)
	{
		delete this;
		return 0;
	}
	return m_cRef;
}

//CreateInstance
HRESULT __stdcall CFactory::CreateInstance(IUnknown *pIUnknownOuter, const IID& iid, void **ppv)
{
	if(pIUnknownOuter != NULL)
	{
		trace("no aggregation");
		return CLASS_E_NOAGGREGATION;
	}
	//Create Compnent1
	CA *pA = new CA();
	if(pA == NULL)
	{
		return E_OUTOFMEMORY;
	}
	HRESULT hr = pA->Init();
	if(FAILED(hr))
	{
		//Initialize failed.Delete Component
		pA->Release();
		return hr;
	}
	//Get Request interface
	hr = pA->QueryInterface(iid, ppv);

	//Release IUnknown interface
	pA->Release();
	return hr;
}

HRESULT __stdcall CFactory::LockServer(BOOL bLock)
{
	if(bLock == TRUE)
	{
		InterlockedIncrement(&g_lServerLocks);
	}	
	else
	{
		InterlockedDecrement(&g_lServerLocks);
	}
	return S_OK;
}

////////////////////////////////////////
//export functions
//
//Get Interface IClassFactory
STDAPI DllGetClassObject(const CLSID& clsid, const IID& iid, void **ppv)
{
	if(clsid != CLSID_Component1)
		return CLASS_E_CLASSNOTAVAILABLE;

	CFactory *pFactory = new CFactory();
	if(pFactory == NULL)
	{
		return E_OUTOFMEMORY;
	}
	HRESULT hr = pFactory->QueryInterface(iid, ppv);
	pFactory->Release();
	return hr;
}

STDAPI DllCanUnloadNow()
{
	if(g_lComponent == 0 && g_lServerLocks == 0)
		return S_OK;
	else
		return S_FALSE;
}

STDAPI DllRegisterServer()
{
	return RegisterServer(g_hModule,
						  CLSID_Component1,
						  g_szFriendlyName,
						  g_szVerIndProgID,
						  g_szProgID);
}

STDAPI DllUnRegisterServer()
{
	return UnregisterServer(CLSID_Component1,
							g_szVerIndProgID,
							g_szProgID);
}

BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpvReserved)
{
	if(dwReason == DLL_PROCESS_ATTACH)
	{
		g_hModule = hModule;
	}
	return TRUE;
}

cmpnt1.def
LIBRARY cmpnt1.dll
DESCRIPTION 'Chapter08 Component1'

EXPORTS DllGetClassObject   @2 private
        DllCanUnloadNow     @3 private
        DllRegisterServer   @4 private
		DllUnRegisterServer @5 private

组件1和组件2公用的文件

iface.h

#include <objbase.h>

interface IX:IUnknown
{
	virtual void __stdcall Fx() = 0;
};

interface IY:IUnknown
{
	virtual void __stdcall Fy() = 0;
};

extern const IID IID_IX;  //Interface ID for IX
extern const IID IID_IY;  //Interface ID for IY

extern const CLSID CLSID_Component1; //CLSID for Cmpnt1 
extern const CLSID CLSID_Component2; //CLSID for Cmpnt2

guids.cpp 

#include <objbase.h>

// {32bb8320-b41b-11cf-a6bb-0080c7b2d682}
extern const IID IID_IX = 
	{0x32bb8320, 0xb41b, 0x11cf,
	{0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

// {32bb8321-b41b-11cf-a6bb-0080c7b2d682}
extern const IID IID_IY = 
	{0x32bb8321, 0xb41b, 0x11cf,
	{0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

// {0c092c22-882c-11cf-a6bb-0080c7b2d682}
extern const CLSID CLSID_Component1 =
	{0x0c092c22, 0x882c, 0x11cf,
	{0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

// {0c092c23-882c-11cf-a6bb-0080c7b2d682}
extern const CLSID CLSID_Component2 =
	{0x0c092c23, 0x882c, 0x11cf,
	{0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;


注册表文件registry.h和registry.cpp与chap07相同

运行结果




包容的主要用途

包容的主要用途是通过给已有的接口加上代码以扩展此接口。

linux的com技术,《com 技术内幕》
weixin_36044132的博客
05-16 1154
《com 技术内幕》第1章 组件1、COM，即组件对象模型，是关于如何建立组件以及如何通过组件建构应用程序的一个规范。2、组件的优点：应用程序可随时间的流逝而发展变化；定制应用程序；组件库；分布式组件。3、对组件的需求：组件必须动态连接；必须隐藏其内部实现细节。4、COM组件是以Win32动态链接库(DLLs)或可执行文件(EXEs)的形式发布的可执行代码组成的。遵循COM规范编写的组件将能够满足...
MySQL技术内幕-InnoDB存储引擎读书笔记
yx185的博客
01-14 941
MySQL技术内幕-InnoDB存储引擎读书笔记 第1章 MySQL体系结构和存储引擎 1.1 定义数据库和实例 数据库：物理操作系统文件或其他形式文件类型的集合； 实例：MySQL数据库由后台线程以及一个共享内存区组成；在系统上的表现就是一个进程。 1.2 MySQL体系结构 数据库是由一个个文件组成，要对这些文件执行增删查改等数据库操作是不能通过简单的操作文件来更改数据库的内容，需要通过...
COM技术内幕(含源码)
03-10
COM技术内幕(含源码)，最低分搬砖，供大家学习交流。文档是扫描版，能看清楚。
COM技术内幕（笔记）
bigwudan的专栏
03-24 2106
健忘日记 欢迎UI开发交流与合作 duwenjie@gmail.com 博客园首页博问闪存新随笔联系订阅管理 随笔- 144  文章- 0  评论- 63  COM技术内幕（笔记） COM——到底是什么？——COM标准的要点介绍，它被设计用来解决什么问题？基本元素的定义——COM术语以及这些术语的含义。 使用和处理COM对象
COM技术内幕
庸人自扰
01-09 4099
 COM技术内幕第一章 组件将单个应用程序分隔成多个独立的部分，即组件。对组件的需求：动态连接，信息封装。对组件的限制：1。语言无关；2.升级不妨碍使用；3.位置透明.COM是一个说明如何建立可动态互变组件的规范。第二章 接口对com来说，接口是一个包含一个函数指针数组的内存结构。每一个数组元素包含的是一个由组件所实现的函数的地址。对于com而言，接口就是此内存
MySQL技术内幕InnoDB存储引擎-读书笔记.pdf
10-14
MySQL技术内幕InnoDB存储引擎-读书笔记.pdf
VC++技术内幕-学习笔记
04-24
总的来说，《VC++技术内幕》的学习笔记强调了理论与实践的结合，从WinMain函数到MFC框架，从GDI到DLL，再到源代码浏览器的使用，每一个知识点都是Windows平台上高效编程的基础。通过深入学习和实践，开发者可以提升...
读书笔记：《高性能MySQL》《MySQL技术内幕InnoDB存储引擎》阅读笔记.zip
最新发布
07-25
读书笔记：《高性能MySQL》《MySQL技术内幕InnoDB存储引擎》阅读笔记
com技术内幕--读书笔记（7）
simeone18的专栏
12-15 4411
第7章 类厂 相信有了前六章的知识积累，学些以后的章节将会很顺利。本章实现了一个真正的COM组件，并通过client客户端来使用这个组件。学完这章，对COM组件的最基本的东西就已经学完了，可以实现一个真正意义上的组件，后续几章就是在此基础上进行的升华，例如组件的复用，EXE中的组件，多线程等等，也同样重要。 本章将介绍类厂，类厂是能够创建其他组件的组件，并且可以使用同一个类厂来创建
COM 技术内幕——微软组件对象模型(PDF).pdf
03-19
COM 技术内幕——微软组件对象模型(PDF).pdf
COM技术内幕.pdf
06-15
COM技术内幕 微软 组件对象模型 老美的书 基本上都是好书 把COM技术介绍的淋漓尽致 我免费奉送
COM技术内幕（PDF电子书和C++源码）
07-28
涉及COM开发的一些技术介绍，包含PDF电子书文档和相关C++实现原码
COM技术内幕(含源码)pdf
05-27
COM技术内幕(含源码)pdf
COM技术内幕 微软组件对象模型
03-28
COM技术内幕》是一本很有意思的书，可以说是中级程序员到高级程序员的过渡，有兴趣的朋友不防学学。COM，即Microsoft组件对象模型（Component Object Model），是开发软件组件的一种方法。组件实际上是一些小的二进制可执行程序，它可以给应用程序、操作系统以及其他组件提供一些服务。开发定制的COM组件就如同开发动态的、面向对象的API。多个COM对象可以连接起来以形成应用程序或组件系统，并且组件可以在运行时，在不重新链接或者编译应用程序的情况下被卸下或替换掉。Microsoft的许多技术，如ActiveX、DirectX以及OLE等都是基于COM建立起来的，并且Microsoft的开发人员也大量使用COM组件来定制他们的应用程序及操作系统。下面是网上有关《COM技术内幕》一书的笔记，对COM技术的理解与复习都有一定的好处。
com技术内幕
hsyouxishe的专栏
01-30 774
http://blog.donews.com/piaoger/archive/2004/09/21/105204.aspx （com技术内幕学习） http://www.vckbase.com/document/viewdoc/?id=926 (com调用流程分析)
《COM技术内幕》
van150
10-07 1050
还好，今天网上碰到《COM技术内幕》这本书，并且能下载，着了好久都没找到，书店都买不不到，这下好了，不用往图书城跑了，钞票也省了，网络真好啊。看了两页，写得不错，毕竟是清华出的啊，好了，不多说了，看书。
《COM技术内幕》笔记（1）
无烟会议室的专栏 产品|编程|软件工程|管理|游戏|电子书
01-13 3653
《com 技术内幕》第1章 组件1、COM，即组件对象模型，是关于如何建立组件以及如何通过组件建构应用程序的一个规范。2、组件的优点：应用程序可随时间的流逝而发展变化；定制应用程序；组件库；分布式组件。3、对组件的需求：组件必须动态连接；必须隐藏其内部实现细节。4、COM组件是以Win32动态链接库（DLLs）或可执行文件（EXEs）的形式发布的可执行代码组成的。遵循COM规范编写的组
深入解析VC++技术内幕的实用学习笔记
『VC++技术内幕』学习笔记.chm文件是将学习笔记制作成电子文档格式，方便用户通过电脑阅读和搜索学习内容。 5. PUDN资源链接文件 ***.txt文件可能包含的是指向PUDN（程序员大本营）的链接。PUDN是一个以程序员为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值