com学习3——包容

最新推荐文章于 2021-11-04 15:43:31 发布
最新推荐文章于 2021-11-04 15:43:31 发布
阅读量97 收藏
点赞数
原文链接：http://www.cnblogs.com/waterhsu/archive/2012/05/02/com_contain.html
版权
com 有两种重要的重用模型—包容和聚合。重用是现在软件开发中很看重的一部分。重用可以大大提高开发效率。com的这两个重用模型非常的经典。包容：有两个com对象，A,B，用户只知道com对象B的存在，并不知道com对象A的存在，而com对象B知道对象A的存在，并且com对象B中的一部分功能com对象A中已经实现，com对象B有这些功能函数但是不去自己实现这部分功能，而是去调用对象A的这部分功能，当用户调用对象B的这部分功能的时候，对象B就去调用对象A的这些功能，并将结果返回给用户。聚合：则重用的更彻底，对象B根本就不去实现那部分功能，连函数都没有，用户调用对象B的那部分功能的时候，对象B直接将对象A的那部分接口暴露给用户，用户直接调用到了对象A。但是对象A受对象B的控制。
包容：

 
聚合：
 

这次只介绍包容的实现，聚合下次再介绍。
 
包容程序实现：
com对象A：

 
接口：ISomefunction.h
 
#ifndef __ISomefunction_H__
#define __ISomefunction_H__
 
 
#include "Unknwn.h"
 
extern "C" const GUID IID_ISomefunction2;
 
class ISomefunction : public IUnknown
{
public:
virtual void __stdcall Somefunction() = 0;
};
 
#endif
 
 
 
 对象A:A.h
#ifndef __ISomefunction_H__
#include "ISomefunction.h"
 
//#endif
 
class CA : public ISomefunction
{
public:
CA();
~CA();
public:
virtual HRESULT __stdcall QueryInterface(const IID& iid,void **ppv);
virtual ULONG __stdcall AddRef();
virtual ULONG __stdcall Release();
 
public:
virtual void __stdcall Somefunction();
private:
int m_Ref;
};
 
#endif
 
A.cpp
#include "stdafx.h"
 
 
 
 
#include <comutil.h>
#include <stdio.h>
#include "objbase.h"
#include "olectl.h"
 
 
#include "A.h"
#include "Factory.h"
#include "Registry.h"
 
 
// {D45EAF90-D34A-4F89-98AD-2084765D711B}
extern "C" const GUID CLSID_A =
{ 0xd45eaf90, 0xd34a, 0x4f89, { 0x98, 0xad, 0x20, 0x84, 0x76, 0x5d, 0x71, 0x1b } };
extern "C" const GUID IID_ISomefunction2 =
{ 0xd45eaf92, 0xd34a, 0x4f89, { 0x98, 0xad, 0x20, 0x84, 0x76, 0x5d, 0x71, 0x1b } };
 
ULONG g_LockNumber = 0;
ULONG g_ANumber = 0;
HANDLE g_hModule;
 
 
 
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
g_hModule = hModule;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
 
 
extern "C" HRESULT __stdcall DllGetClassObject(const CLSID& clsid,const IID& iid,void **ppv)
{
if(clsid == CLSID_A)
{
//CAFactory *pFactory = new CAFactory;
CAFactory *pFactory = new CAFactory;
if(pFactory == NULL) return E_OUTOFMEMORY;
 
HRESULT result = pFactory->QueryInterface(iid,ppv);
return result;
}
else return CLASS_E_CLASSNOTAVAILABLE;
}
 
extern "C" HRESULT __stdcall DllCanUnloadNow(void)
{
if((g_ANumber == 0) && (g_LockNumber == 0)) return S_OK;
else return S_FALSE;
}
 
extern "C" HRESULT __stdcall DllRegisterServer()
{
char szModule[1024];
DWORD dwResult = ::GetModuleFileName((HMODULE)g_hModule,szModule,1024);
if(dwResult == 0) return SELFREG_E_CLASS;
return RegisterServer(CLSID_A,szModule,"A.Object","A Component",NULL);
}
 
extern "C" HRESULT __stdcall DllUnregisterServer()
{
return UnregisterServer(CLSID_A,"A.Object",NULL);
}
 
CA::CA()
{
m_Ref = 0;
g_ANumber++;
}
 
CA::~CA()
{
 
}
 
HRESULT CA::QueryInterface(const IID& iid,void **ppv)
{
if(iid == IID_IUnknown)
{
*ppv = (ISomefunction *)this;
((ISomefunction *)(*ppv)) ->AddRef();
}
else if(iid == IID_ISomefunction2)
{
*ppv = (ISomefunction *)this;
((ISomefunction *)(*ppv)) ->AddRef();
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
return S_OK;
}
 
ULONG CA::AddRef()
{
m_Ref++;
return (ULONG)m_Ref;
}
 
ULONG CA::Release()
{
m_Ref--;
if(m_Ref == 0)
{
g_ANumber--;
delete this;
return 0;
}
return (ULONG)m_Ref;
}
 
void CA::Somefunction()
{
printf("********************************\nCall function from A.\n********************************\n");
}
 
类厂：Factory.h
#ifndef __Factory_H__
#define __Factory_H__
 
#include "Unknwn.h"
 
 
class CAFactory : public IClassFactory
{
protected:
ULONG m_Ref;
public:
CAFactory();
~CAFactory();
 
 
virtual HRESULT __stdcall QueryInterface(const IID& iid,void **ppv);
virtual ULONG __stdcall AddRef();
virtual ULONG __stdcall Release();
public:
virtual HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter,const IID &iid,void **ppv);
virtual HRESULT __stdcall LockServer(BOOL);
};
 
#endif
 
Factory.cpp
#include "stdafx.h"
#include "Factory.h"
#include "A.h"
 
extern ULONG g_LockNumber;
extern ULONG g_ANumber;
 
 
CAFactory::CAFactory()
{
m_Ref = 0;
}
 
CAFactory::~CAFactory()
{
 
}
 
HRESULT CAFactory::QueryInterface(const IID& iid,void **ppv)
{
if(iid == IID_IUnknown)
{
*ppv = (IUnknown *)this;
((IUnknown*)(*ppv))->AddRef();
}
else if(iid == IID_IClassFactory)
{
*ppv = (IClassFactory*)this;
((IClassFactory*)(*ppv))->AddRef();
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
return S_OK;
}
 
ULONG CAFactory::AddRef()
{
m_Ref++;
return (ULONG)m_Ref;
}
 
ULONG CAFactory::Release()
{
m_Ref--;
if(m_Ref == 0)
{
delete this;
return 0;
}
return (ULONG)m_Ref;
}
 
HRESULT CAFactory::CreateInstance(IUnknown *pUnknownOuter,const IID& iid,void **ppv)
{
CA *pObj;
HRESULT hr;
 
*ppv = NULL;
hr = E_OUTOFMEMORY;
if(NULL != pUnknownOuter) return CLASS_E_NOAGGREGATION;
 
pObj = new CA();
if(pObj == NULL) return hr;
 
hr = pObj->QueryInterface(iid,ppv);
if(hr != S_OK)
{
g_ANumber--;
delete pObj;
}
 
return hr;
}
 
HRESULT CAFactory::LockServer(BOOL bLock)
{
if(bLock) g_LockNumber++;
else g_LockNumber--;
 
return NOERROR;
}
Registry.h  Registry.cpp 和 .def文件跟之前的都是一样的，不再介绍。
 
com对象B
 

 
代码：
接口：ISomefunction.h
#ifndef __ISomefunction_H__
#define __ISomefunction_H__
 
#include "Unknwn.h"
 
extern "C" const GUID IID_ISomefunction;
 
class ISomefunction : public IUnknown
{
public:
virtual void __stdcall Somefunction() = 0;
};
 
#endif
 
IOtherfunction.h
#ifndef __IOtherfunction_H__
#define __IOtherfunction_H__
 
#include "Unknwn.h"
 
extern "C" const GUID IID_IOtherfunction;
 
class IOtherfunction : public IUnknown
{
public:
virtual void __stdcall Otherfunction() = 0;
};
 
#endif
 
对象B:B.h
#ifndef __ISomefunction_H__
#include "ISomefunction.h"
 
#endif
 
#ifndef __IOtherfunction_H__
#include "IOtherfunction.h"
 
#endif
 
class CB : public ISomefunction,public IOtherfunction
{
public:
CB();
~CB();
public:
virtual HRESULT __stdcall QueryInterface(const IID& iid,void **ppv);
virtual ULONG __stdcall AddRef();
virtual ULONG __stdcall Release();
 
public:
virtual void __stdcall Somefunction();
public:
virtual void __stdcall Otherfunction();
public:
HRESULT Init();
private:
int m_Ref;
ISomefunction *m_pSomefunction;
};
 
B.cpp
#include "stdafx.h"
 
 
 
#include <comutil.h>
#include <stdio.h>
#include "objbase.h"
#include "olectl.h"
 
#include "B.h"
#include "Factory.h"
#include "Registry.h"
 
 
extern "C" const GUID CLSID_A =
{ 0xd45eaf90, 0xd34a, 0x4f89, { 0x98, 0xad, 0x20, 0x84, 0x76, 0x5d, 0x71, 0x1b } };
 
 
extern "C" const GUID IID_ISomefunction2 =
{ 0xd45eaf92, 0xd34a, 0x4f89, { 0x98, 0xad, 0x20, 0x84, 0x76, 0x5d, 0x71, 0x1b } };
 
 
extern "C" const GUID CLSID_B =
{ 0x67c51297, 0xc0d7, 0x4c58, { 0x85, 0x23, 0x6c, 0xa6, 0x1b, 0x2c, 0xdd, 0x6c } };
 
extern "C" const GUID IID_ISomefunction =
{ 0x67c51298, 0xc0d7, 0x4c58, { 0x85, 0x23, 0x6c, 0xa6, 0x1b, 0x2c, 0xdd, 0x6c } };
 
extern "C" const GUID IID_IOtherfunction =
{ 0x67c51299, 0xc0d7, 0x4c58, { 0x85, 0x23, 0x6c, 0xa6, 0x1b, 0x2c, 0xdd, 0x6c } };
 
ULONG g_LockNumber = 0;
ULONG g_BNumber = 0;
HANDLE g_hModule;
 
 
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
g_hModule = hModule;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
 
 
 
extern "C" HRESULT __stdcall DllGetClassObject(const CLSID& clsid,const IID& iid,void **ppv)
{
if(clsid == CLSID_B)
{
CBFactory *pFactory = new CBFactory;
if(pFactory == NULL) return E_OUTOFMEMORY;
 
HRESULT result = pFactory->QueryInterface(iid,ppv);
return result;
}
else return CLASS_E_CLASSNOTAVAILABLE;
}
 
extern "C" HRESULT __stdcall DllCanUnloadNow(void)
{
if((g_BNumber == 0) && (g_LockNumber == 0)) return S_OK;
else return S_FALSE;
}
 
extern "C" HRESULT __stdcall DllRegisterServer()
{
char szModule[1024];
DWORD dwResult = ::GetModuleFileName((HMODULE) g_hModule,szModule,1024);
if(dwResult == 0) return SELFREG_E_CLASS;
return RegisterServer(CLSID_B,szModule,"B.Object","B Component",NULL);
}
 
extern "C" HRESULT __stdcall DllUnregisterServer()
{
return UnregisterServer(CLSID_B,"B.Object",NULL);
}
 
 
CB::CB()
{
m_pSomefunction = NULL;
m_Ref = 0;
g_BNumber++;
}
 
CB::~CB()
{
if(m_pSomefunction != NULL) m_pSomefunction->Release();
}
 
HRESULT CB::Init()
{
HRESULT result = ::CoCreateInstance(CLSID_A,NULL,CLSCTX_INPROC_SERVER,IID_ISomefunction2,(void **)&m_pSomefunction);
if(FAILED(result)) return E_FAIL;
else return S_OK;
}
 
void CB::Somefunction()
{
m_pSomefunction->Somefunction();
}
 
void CB::Otherfunction()
{
printf("*************************************\nCall function from B.\n*************************************\n");
}
 
HRESULT CB::QueryInterface(const IID& iid,void **ppv)
{
if(iid == IID_IUnknown)
{
*ppv = (ISomefunction *)this;
((ISomefunction *)(*ppv))->AddRef();
}
else if(iid == IID_ISomefunction)
{
*ppv = (ISomefunction *)this;
((ISomefunction *)(*ppv))->AddRef();
}
else if(iid == IID_IOtherfunction)
{
*ppv = (IOtherfunction *)this;
((IOtherfunction *)(*ppv))->AddRef();
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
return S_OK;
}
 
 
ULONG CB::AddRef()
{
m_Ref++;
return (ULONG)m_Ref;
}
 
ULONG CB::Release()
{
m_Ref--;
if(m_Ref == 0)
{
g_BNumber--;
delete this;
return 0;
}
return (ULONG)m_Ref;
}
 
类厂实现：Factory.h
#ifndef __Factory_H__
#define __Factory_H__
 
 
#include "Unknwn.h"
 
class CBFactory : public IClassFactory
{
protected:
ULONG m_Ref;
public:
CBFactory();
~CBFactory();
public:
virtual HRESULT __stdcall QueryInterface(const IID& iid,void **ppv);
virtual ULONG __stdcall AddRef();
virtual ULONG __stdcall Release();
 
public:
virtual HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter,const IID &iid,void **ppv);
virtual HRESULT __stdcall LockServer(BOOL);
};
 
#endif
 
Factory.cpp
#include "stdafx.h"
#include "Factory.h"
#include "B.h"
 
extern ULONG g_LockNumber;
extern ULONG g_BNumber;
 
 
CBFactory::CBFactory()
{
m_Ref = 0;
}
 
CBFactory::~CBFactory()
{
 
}
 
HRESULT CBFactory::QueryInterface(const IID& iid,void **ppv)
{
if(iid == IID_IUnknown)
{
*ppv = (IUnknown *)this;
((IUnknown *)(*ppv)) ->AddRef();
}
else if(iid == IID_IClassFactory)
{
*ppv = (IClassFactory *)this;
((IClassFactory *)(*ppv))->AddRef();
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
return S_OK;
}
 
ULONG CBFactory::AddRef()
{
m_Ref++;
return (ULONG)m_Ref;
}
 
ULONG CBFactory::Release()
{
m_Ref--;
if(m_Ref == 0)
{
delete this;
return 0;
}
return (ULONG)m_Ref;
}
 
HRESULT CBFactory::CreateInstance(IUnknown *pUnknownOuter,const IID& iid,void **ppv)
{
CB *pObj;
HRESULT hr;
 
*ppv = NULL;
 
hr = E_OUTOFMEMORY;
if(pUnknownOuter != NULL) return CLASS_E_NOAGGREGATION;
 
pObj = new CB();
 
if(pObj == NULL) return hr;
pObj->Init();
hr = pObj->QueryInterface(iid,ppv);
if(hr != S_OK)
{
g_BNumber--;
delete pObj;
}
return hr;
}
 
HRESULT CBFactory::LockServer(BOOL bLock)
{
if(bLock) g_LockNumber++;
else g_LockNumber--;
 
return NOERROR;
}
解释：这里对象B中有个函数Init()，这个函数的作用是调用对象A的接口，将接口指针赋给
m_pSomefunction。对象B中的ISomefunction接口的功能是通过m_pSomefunction指针去调用对象A中的函数。
 
客户调用程序：
 

代码：IOtherfunction.h
#ifndef __IOtherfunction_H__
#define __IOtherfunction_H__
 
#include "Unknwn.h"
 
extern "C" const GUID IID_IOtherfunction;
 
class IOtherfunction : public IUnknown
{
public:
virtual void __stdcall Otherfunction() = 0;
};
 
#endif
 
ISomefunction.h
#ifndef __ISomefunction_H__
#define __ISomefunction_H__
 
#include "Unknwn.h"
 
extern "C" const GUID IID_ISomefunction;
 
class ISomefunction : public IUnknown
{
public:
virtual void __stdcall Somefunction() = 0;
};
 
#endif
 
call.cpp
#include "stdafx.h"
 
#include <stdio.h>
#include <comutil.h>
 
#include "ISomefunction.h"
#include "IOtherfunction.h"
 
 
extern "C" const GUID CLSID_B =
{ 0x67c51297, 0xc0d7, 0x4c58, { 0x85, 0x23, 0x6c, 0xa6, 0x1b, 0x2c, 0xdd, 0x6c } };
 
extern "C" const GUID IID_ISomefunction =
{ 0x67c51298, 0xc0d7, 0x4c58, { 0x85, 0x23, 0x6c, 0xa6, 0x1b, 0x2c, 0xdd, 0x6c } };
 
extern "C" const GUID IID_IOtherfunction =
{ 0x67c51299, 0xc0d7, 0x4c58, { 0x85, 0x23, 0x6c, 0xa6, 0x1b, 0x2c, 0xdd, 0x6c } };
 
 
/*extern "C" const GUID CLSID_B =
{0x54bf6567, 0x1007, 0x11d1, {0xb0, 0xaa, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}};
 
extern "C" const IID IID_Dictionary =
{ 0x54bf6568, 0x1007, 0x11d1,
{ 0xb0, 0xaa, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00} } ;
 
extern "C" const IID IID_SpellCheck =
{ 0x54bf6569, 0x1007, 0x11d1,
{ 0xb0, 0xaa, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00} } ;*/
 
 
 
 
 
int _tmain(int argc, _TCHAR* argv[])
{
 
IUnknown *pUnknown;
ISomefunction *pSomefunction;
IOtherfunction *pOtherfunction;
HRESULT hResult;
 
if(CoInitialize(NULL) != S_OK) printf("Initialize COM library failed!\n");
 
hResult = CoCreateInstance(CLSID_B,NULL,CLSCTX_INPROC_SERVER,IID_IUnknown,(void **)&pUnknown);
 
if(hResult != S_OK) printf("Create object failed!\n");
 
hResult = pUnknown->QueryInterface(IID_ISomefunction,(void **)&pSomefunction);
if(hResult != S_OK)
{
pUnknown->Release();
printf("QueryInterface ISomefunction failed!\n");
return 0;
}
 
pSomefunction->Somefunction();
 
hResult = pSomefunction->QueryInterface(IID_IOtherfunction,(void **)&pOtherfunction);
pOtherfunction->Release();
if(hResult != S_OK)
{
pUnknown->Release();
printf("QueryInterface IOtherfunction failed!\n");
return 0;
}
pOtherfunction->Otherfunction();
 
pOtherfunction->Release();
CoUninitialize();
int m;
scanf("%d",&m);
return 0;
}
 
运行结果：

转载于:https://www.cnblogs.com/waterhsu/archive/2012/05/02/com_contain.html

weixin_30559481
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
学习标准——笔记
10-31
学习标准——笔记
COM的“可重用性”特性包括两种模型：包容和聚合
IT民工
05-28 3649
包容和聚合是COM的两种重用模型，它们的思路基本一致，只是在实现方法上有所不同，下面简要总结一下实现方法： 1.包容：     假定我们已经实现了一个COM对象，不妨称它为对象A，它实现了接口ISomeIntf，不久之后，考虑到新的需要，我们要实现一个新的COM对象，称它为B，它既要实现接口ISomeIntf，也要实现接口IOtherIntf，而且，ISomeIntf接口所提供的服务与对象A所
C++ 中的智能指针
年年年的博客
11-04 309
1. 智能指针出现的原因 动态内存管理经常会出现两种问题： 忘记释放内存，会造成内存泄漏； 尚有指针引用内存的情况下就释放了它，就会产生引用非法内存的指针。 为了更加容易（更加安全）的使用动态内存，引入了智能指针的概念。 在智能指针中主要存在以下4种智能指针分别是：auto_ptr, unique_ptr,shared_ptr, weak_ptr 其中后三个是C++11支持，并且第一个已经被C++11弃用。 2. 常见智能指针的演示与特点 2.1 auto_ptr （C++98的方案，C++11已经抛弃
COM技术内幕--包容和聚合
crkres9527
12-19 804
包容简介： 一个包含有一个内部组件并使用了其IZ接口的外部组件的内部结构 ////////////////////////////// 在COM中，同其他内容类似，包容也是在接口级完成的。 一个包含有一个内部组件并复用了其IY接口实现的外部组件的内部结构 /////////////// 当外部组件聚合某个接口时，它将
COM笔记-包容与聚合
weixin_30767835的博客
08-29 101
COM不支持实现继承的原因在于这种继承方式将使得一个对象的实现同另外一个对象的实现紧紧地关联起来。在这种情况下，当基类的实现被修改后，派生类将无法正常运行而必须被修改。这就是为什么一些用C++编写大型程序的专家们强烈建议人们基于抽象类来构建应用程序。 因此，为了保证以组件的修改不会影响应用程序的正常运行，COM并不支持实现继承。我们可以用组件包容来完全模拟实现继承。 包容和聚合 　对...
COM 的聚合和包容
allenhiman的专栏
03-27 790
我们可以这样去认识它们 包容(Containment/Delegate)com的包容就是在自己的组件里利用别人的组件。实现这种目的的步骤很简单：如下代码HRESULT FinalConstruct() {  HRESULT hr;  hr = CoCreateInstance( CLSID_SimpleMath, NULL,          CLSCTX_INPROC_SER
Python学习笔记——运算符
12-10
Python学习笔记——运算符 运算符: 赋值运算符 算术运算符 关系运算符 逻辑运算符 位运算
Solidworks学习笔记——随形变化.docx
07-13
Solidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——随形变化.docxSolidworks学习笔记——...
RRT学习笔记——记录
04-12
RRT学习笔记——记录
C语言学习笔记——小浪神
10-04
C语言学习笔记——小浪神
【Win32】进程内COM的两种复用方式（包容和聚合）
08-16
进程内COM组件的两种复用方式，包容和聚合，压缩包内有两个工程与之对应。采用Win32 API，VC8，非ATL或MFC实现。
COM组件的集合与包容
jiangqin115的专栏
11-25 344
集合与包容，实质就是组件之间的互相调用。即一个组件使用另一个组件的功能，达到代码复用的作用。只是这种复用是构建在二进制数据上的（因为被复用的组件常常以dll的格式存在），而不是像c++代码复用是以源文件的形式复用。 集合与包容的区别在于： 包容是将内组件的功能进行封装，由外组件提供接口供客户调用，但实质执行任务的仍然是内组件。 集合是将内组件的功能暴露出来供客户调用，让客户感觉好像调用的是外...
C++ 智能指针
Christo的博客
10-15 321
文章目录前言1，aoto_ptr2，unique_ptr3，share_ptr4, weak_ptr 前言 如果在程序中使用new从堆分配内存，等到不再需要时，应使用delete将其释放，C++引入了智能指针auto_ptr，以帮助自动完成这个过程，但是aoto_ptr也有其局限性，因此从Boost库中又引入了三种智能指针unique_ptr shared_ptr weak_ptr。 1，aoto_ptr // ConsoleApplication1.cpp : 定义控制台应用程序的入口点。 // #in
COM包容和聚合
iteye_16714的博客
03-16 207
   包容和聚合实际上是一个组件使用另一个组件的技术。对于这两个组件，可以把第一个组件称为外部组件，被使用组件称为内部组件。      1、包容简介      COM包容同C++包容是相似的。但是在COM中，同其他内容类似，包容也是在接口级完成的。外部组件包含指向内部组件接口的指针。此时外部组件只是内部组件的一个客户，它将使用内部组件的接口来实现自己的接口。      外边组件也可以通过将调...
com 包容类实现多个双重接口
FrankieWang008的专栏
06-10 1859
有时项目组件X已经实现了接口 IA 中的
C++模板实现事件处理器中的“通用成员函数指针”的调用（二）
weixin_30808253的博客
07-03 60
接上一篇《C++模板实现事件处理器中的“通用成员函数指针”的调用（一）》上一篇的最后，好像缺了点东西，呵呵，看来我还得给他补上。您有没有发现FuncItem有点问题吗？谁来给成员handler赋值呢？交给构造函数吧，改造后的FuncItem如下：template<typenameT>classFuncItem:publicFuncCaller{private:typ...
COM 包容组件
Jason5563的博客
05-09 144
 效果： &lt;!--StartFragment --&gt;文件说明： 1、客户端 ： CLIENT.cpp： main方法 Contain.exe ：编译后的执行程序 GUIDS.CPP： GUID相关定义 IFACE.H：接口定义 2、组件： CMPNT1.cpp： 外部组件 CMPNT1.def： 接口定义 Cmpnt1.dll：编译后的DLL CMPNT2.cpp 内部组件 CMPNT...
COM对象包容
dasgk的专栏
05-27 766
说到对象包容不可不提的便是对象聚合，其用意都是代码的可重用性的一种方式，刚刚看完了对象包容，所以在这儿写下自己的理解, 其适用场所是，当有对象A实现了someinterface接口的功能，对象B实现了otherinterface接口的功能，当需求改变时，要求，B实现一种新的功能，但是该功能在A中已经实 现，所以此时要实现代码的可重用性，对象B的新功能调用对象A的功能函数，而不再自己重新实现，当
COM原理之包容与聚合
xsh_123321的专栏
09-08 2605
1.包容和聚合的概念包容和聚合实际上是使一个组件使用另外一个组件的一种技术。包容的情况下，客户只能看到外部组件的接口，而外部组件接口的实现是通过转发给内部组件实现的。聚合的情况下，直接将内部组件的借口暴漏给客户，虽然客户不知道内部组件的存在。2.包容的实现包容的实现比较简单，例如外部组件CA（接口IX，IY，其中IY转发给内部组件），内部组件CB（接口IY）。组件CA中添加一成员变量，用于保存内部组件CB的接口指针：private:   IY* m_pIY;CA中Fy函数的实现：Virtual void _
全志t3开发板——嵌入式入门学习测试教程
最新发布
09-28
全志T3开发板是一块能够帮助嵌入式初学者进行学习和测试的开发板。该开发板采用了全志公司推出的T3芯片作为主控芯片，拥有强大的处理性能和丰富的硬件接口，非常适合初学者进行嵌入式开发。 在使用全志T3开发板进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值