COM原理与实现之二: 聚合
C++没有同聚合等价的特性。聚合实际上是继承性的一种动态形式。而C++的继承总是静态的，是实现继承。COM是接口继承，通过聚合接口，可以做成动态配置。
研究COM，主要是利用接口继承的灵活性构筑强大的系统：可配置、可插拔、可脚本化。本文不讲太多理论，详细原理参考[COM技术内幕]这本书。关于[COM技术内幕]，很多内容过时了，比如注册表，类厂之类的。我更关心COM思想所蕴含的哲学。我实现了跨平台COM，支持聚合。
GameStencil这个组件聚合了SystemMngmt这个组件。最初采用IGameStencil::getSystemMngmt()这样的形式返回一个ISystemMngmt接口指针，显然这不是聚合。通过A对象的方法得到B对象，显然A仅仅是B的一种类厂。于是我下决心解决组件聚合问题。就有了本文。
core目录下面就3个文件，是我的跨平台COM的基础。
1） Platform.h
/**
* Platform.h
*
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-10
*/
#ifndef PLATFORM_H
#define PLATFORM_H
#if defined _MSC_VER || WIN32
#ifndef OS_PLATFORM_WIN
#define OS_PLATFORM_WIN
#endif
#endif
#ifdef OS_PLATFORM_WIN
#include <windows.h>
#include <process.h>
#else
#include <pthread.h>
#include <unistd.h>
#endif
#ifndef interface
#define interface struct
#endif
/**
* interface iid
*/
typedef unsigned int iid_t;
/**
* long result
*/
typedef long lresult_t;
#define lres_success 0
#define lres_error (-1)
#define lres_e_initdata (-2)
#define lres_e_outmemory (-4)
#define lres_e_nointerface (-11)
#define lres_e_noaggregation (-12)
/**
* thread_ctx
*/
#define thread_ctx_single 0
#define thread_ctx_multiple 1
/**
* ref count type
*/
#ifdef OS_PLATFORM_WIN
typedef volatile unsigned long refcount_t;
#define __interlock_inc(add) InterlockedIncrement(add)
#define __interlock_dec(sub) InterlockedDecrement(sub)
#else
typedef volatile size_t refcount_t;
#define __interlock_inc(add) __sync_add_and_fetch(add,1)
#define __interlock_dec(sub) __sync_sub_and_fetch(sub,1)
#endif
#endif /* PLATFORM_H */
2） Universal.h
/**
* Universal.h
*
* Refer:
* <<Inside COM>>
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-13
*/
#ifndef UNIVERSAL_H
#define UNIVERSAL_H
#include "Platform.h"
// IUniversal is a variant from IUnknown
//
interface IUniversal
{
static const iid_t IID = ((iid_t) (0));
virtual lresult_t query(iid_t iid,void **ppvOut) = 0;
virtual unsigned long retain(void) = 0;
virtual unsigned long release(void) = 0;
};
#define iid_IUniversal (IUniversal::IID)
// Nondelegating IUniversal interface
// - Nondelegating version of IUniversal
//
interface INondelegatingUniversal
{
static const iid_t IID = ((iid_t) (-1));
virtual lresult_t NondelegatingQuery(iid_t iid,void **ppvOut) = 0;
virtual unsigned long NondelegatingRetain(void) = 0;
virtual unsigned long NondelegatingRelease(void) = 0;
};
#define iid_INondelegatingUniversal (INondelegatingUniversal::IID)
class UniversalImpl
{
private:
unsigned thread_ctx;
refcount_t ref_count;
public:
UniversalImpl() :
ref_count(1),thread_ctx(thread_ctx_multiple) {
printf("UniversalImpl\n");
}
virtual ~UniversalImpl() {
printf("~UniversalImpl\n");
}
void init(unsigned threadctx) {
thread_ctx = threadctx;
}
// Notification to derived classes that we are releasing
void finalRelease() {
// Increment reference count for final release
ref_count = 1;
}
unsigned getThreadCtx() const {
return thread_ctx;
}
// IUniversal
//
virtual lresult_t query(iid_t iid,void **ppv) = 0;
virtual unsigned long retain(void) {
if (thread_ctx == thread_ctx_multiple) {
return __interlock_inc(&ref_count);
} else {
return ++ref_count;
}
}
virtual unsigned long release(void) {
if (thread_ctx == thread_ctx_multiple) {
if (__interlock_dec(&ref_count) == 0) {
delete this;
return 0;
}
} else {
if (--ref_count == 0) {
delete this;
return 0;
}
}
return ref_count;
}
};
// Declaration of NondelegatingUniversalImpl
// - Base class for implementing INondelegatingUniversal
//
class NondelegatingUniversalImpl : public INondelegatingUniversal
{
public:
virtual lresult_t NondelegatingQuery(iid_t iid,void **ppv) = 0;
virtual unsigned long NondelegatingRetain(void) {
if (thread_ctx == thread_ctx_multiple) {
return __interlock_inc(&ref_count);
} else {
return ++ref_count;
}
}
virtual unsigned long NondelegatingRelease(void) {
if (thread_ctx == thread_ctx_multiple) {
if (__interlock_dec(&ref_count) == 0) {
delete this;
return 0;
}
} else {
if (--ref_count == 0) {
delete this;
return 0;
}
}
return ref_count;
}
// Constructor
NondelegatingUniversalImpl(IUniversal* pUniversalOuter) :
ref_count(1) {
// Set outer_universal pointer
if (! pUniversalOuter) {
// Not aggregating; delegate to nondelegating IUniversal
m_pUniversalOuter = reinterpret_cast<IUniversal*>
(static_cast<INondelegatingUniversal*>
(this));
} else {
// Aggregating; delegate to outer IUniversal
m_pUniversalOuter = pUniversalOuter;
}
}
// Destructor
virtual ~NondelegatingUniversalImpl() {
}
// Initialization (especially for aggregates)
void init(unsigned threadctx) {
thread_ctx = threadctx;
}
// Notification to derived classes that we are releasing
virtual void finalRelease() {
// Increment reference count for final release
ref_count = 1;
}
protected:
// Support for delegation
IUniversal* getUniversalOuter() const {
return m_pUniversalOuter;
}
private:
// thread context
unsigned thread_ctx;
// Reference count for this object
refcount_t ref_count;
// Pointer to (external) outer IUniversal
IUniversal* m_pUniversalOuter;
};
///////////////////////////////////////////////////////////
//
// Delegating IUniversal
// - Delegates to the nondelegating IUniversal,or to the
// outer IUniversal if the component is aggregated.
//
#define DECLARE_UNIVERSAL_INTERFACE \
virtual lresult_t query(iid_t iid,void **ppv) { \
return getUniversalOuter()->query(iid,ppv); \
} \
virtual unsigned long retain(void) { \
return getUniversalOuter()->retain(); \
} \
virtual unsigned long release(void) { \
return getUniversalOuter()->release(); \
}
#define CREATE_INSTANCE_NO_AGGREGATION(className) \
static lresult_t createInstance(\
unsigned threadctx,\
IUniversal *pUniversalOuter,\
iid_t iid,\
void **ppv) {\
/* cannot be aggregated */ \
if (pUniversalOuter) {\
return lres_e_noaggregation; \
} \
className * p = new className();\
if ( ! p) {\
return lres_e_outmemory;\
}\
lresult_t hr = p->init(threadctx);\
if (hr != lres_success) {\
p->NondelegatingRelease();\
return hr;\
}\
hr = p->NondelegatingQuery(iid,ppv);\
p->NondelegatingRelease();\
return hr;\
}
#define CREATE_INSTANCE_WITH_AGGREGATION(className) \
static lresult_t createInstance(\
unsigned threadctx,\
IUniversal* pUniversalOuter,\
void **ppv) {\
className * p = new className(pUniversalOuter);\
if ( ! p) {\
return lres_e_outmemory;\
}\
lresult_t hr = p->init(threadctx);\
if (hr != lres_success) {\
p->release();\
return hr;\
}\
hr = p->NondelegatingQuery(iid,ppv);\
p->NondelegatingRelease();\
return hr;\
}
#endif /* UNIVERSAL_H */
3）SIPtr.h
/**
* SIPtr.h
* Smart Interface Pointer
*
* Use: SIPtr<IX> spIX;
* Do not use with IUniversal; SIPtr<IUniversal>
* will not compile. Instead,use IUniversalPtr.
*
* Refer:
* <<Inside COM>>
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-10
*/
#ifndef SIPTR_H
#define SIPTR_H
#include "Universal.h"
#include <assert.h>
template <class T> class SIPtr
{
public:
// Constructors
SIPtr() {
m_pI = 0;
}
SIPtr(T* lp) {
m_pI = lp;
if ( m_pI ) {
m_pI->retain();
}
}
SIPtr(IUniversal* pI) {
m_pI = 0;
if ( pI ) {
pI->query(T::IID,(void **) & m_pI);
}
}
// Destructor
~SIPtr() {
release();
}
// Reset
void release() {
if ( m_pI ) {
T* pOld = m_pI;
m_pI = 0;
pOld->release();
}
}
// Attach to an existing interface (does not retain)
void attach(T * pI) {
if (m_pI != pI) {
IUniversal* pOld = m_pI;
m_pI = pI;
if (pOld) {
// Release the old interface
pOld->release();
}
}
}
// Detach the interface (does not release)
T* detach() {
T* pOld = m_pI;
m_pI = 0;
return pOld;
}
T* get() {
return m_pI;
}
// Conversion
operator T*() {
return m_pI;
}
// Pointer operations
T& operator*() {
assert(m_pI);
return * m_pI;
}
T** operator&() {
assert(!m_pI);
return &m_pI;
}
T* operator->() {
assert(m_pI);
return m_pI;
}
// Assignment from the same interface
T* operator=(T* pI) {
if (m_pI != pI) {
// Save current value
IUniversal* pOld = (IUniversal *) m_pI;
// Assign new value
m_pI = pI;
if (m_pI) {
m_pI->retain();
}
if (pOld) {
// Release the old interface
pOld->release();
}
}
return m_pI;
}
// Assignment from another interface
T* operator=(IUniversal* pI) {
// Save current value
IUniversal* pOld = m_pI;
m_pI = 0;
// Query for correct interface
if ( pI ) {
lresult_t hr = pI->query(T::iid_interface,(void**) & m_pI);
assert(hr == lres_success && m_pI);
}
if ( pOld ) {
// Release old pointer
pOld->release();
}
return m_pI ;
}
// bool functions
bool operator!() {
return m_pI ? false : true;
}
// Requires a compiler that supports BOOL
operator bool() const {
return m_pI ? true : false;
}
// Interface ID
iid_t iid() {
return T::IID;
}
private:
// Pointer variable
T* m_pI;
};
/**
* IUniversalPtr is a smart interface for IUniversal
*/
class IUniversalPtr
{
public:
// Constructors
IUniversalPtr() {
m_pI = 0;
}
IUniversalPtr(IUniversal* lp) {
m_pI = lp;
if ( m_pI ) {
m_pI->retain();
}
}
// Destructor
~IUniversalPtr() {
release();
}
// Reset
void release() {
if (m_pI) {
IUniversal* pOld = m_pI;
m_pI = 0;
pOld->release();
}
}
// Conversion
operator IUniversal*() {
return (IUniversal*) m_pI;
}
// Pointer operations
IUniversal& operator*() {
assert(m_pI);
return *m_pI;
}
IUniversal** operator&() {
assert(!m_pI);
return &m_pI;
}
IUniversal* operator->() {
assert(m_pI);
return m_pI;
}
// Assignment
IUniversal* operator=(IUniversal* pI) {
if (m_pI != pI) {
// Save current value
IUniversal* pOld = m_pI;
// Assign new value
m_pI = pI;
if ( m_pI ) {
m_pI->retain();
}
if ( pOld ) {
// Release the old interface
pOld->release();
}
}
return m_pI;
}
// Boolean functions
bool operator!() {
return m_pI ? false : true;
}
operator bool() const {
return m_pI ? true : false;
}
private:
// Pointer variable
IUniversal* m_pI;
};
#endif /* SIPTR_H */
组件 GameStencil的代码：
/**
* IGameStencil.h
*
* Author: master@pepstack.com
*
* Refer:
* http://www.richardlord.net/blog/what-is-an-entity-framework
* http://blog.csdn.net/i_dovelemon/article/details/30250049
* http://blog.csdn.net/zhao_92221/article/details/46629553
* http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-13
* Last Updated: 2016-06-13
*/
#ifndef IGAME_STENCIL_H
#define IGAME_STENCIL_H
#include "core/SIPtr.h"
namespace ecs {
interface IGameStencil : IUniversal {
static const iid_t IID = ((iid_t) 0x00F000);
virtual void update(float dt) = 0;
};
}; /* namespace ecs */
#endif /* IGAME_STENCIL_H */
/**
* GameStencil.h
* The GameStencil class is the central point for creating
* and managing your game state.
*
* Refer:
* http://www.richardlord.net/blog/what-is-an-entity-framework
* http://blog.csdn.net/i_dovelemon/article/details/30250049
* http://blog.csdn.net/zhao_92221/article/details/46629553
* http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-12
* Last Updated: 2016-06-12
*/
#ifndef GAME_STENCIL_H
#define GAME_STENCIL_H
#include "IGameStencil.h"
#include "SystemMngmt.h"
#include <memory>
#include <vector>
using namespace std;
namespace ecs {
class GameStencil :
public IGameStencil,public NondelegatingUniversalImpl
{
public:
// Creation
//
CREATE_INSTANCE_NO_AGGREGATION(GameStencil)
private:
// Constructor
GameStencil() :
NondelegatingUniversalImpl(0),updating(false),m_pUniversalInner(0) {
printf("GameStencil\n");
m_pISystemMngmt = 0;
}
// Destructor
virtual ~GameStencil() {
finalRelease();
printf("~GameStencil\n");
}
// Initialization
//
virtual lresult_t init(unsigned threadctx) {
NondelegatingUniversalImpl::init(threadctx);
IUniversal * pUniversalOuter = this;
lresult_t hr = SystemMngmt::createInstance(threadctx,pUniversalOuter,IUniversal::IID,(void**) &m_pUniversalInner);
if (hr != lres_success) {
return lres_error;
}
hr = m_pUniversalInner->query(ISystemMngmt::IID,(void**) &m_pISystemMngmt);
if (hr != lres_success) {
m_pUniversalInner->release();
return lres_error;
}
pUniversalOuter->release();
return lres_success;
}
virtual void finalRelease() {
NondelegatingUniversalImpl::finalRelease();
getUniversalOuter()->retain();
m_pISystemMngmt->release();
if (m_pUniversalInner) {
m_pUniversalInner->release();
}
}
// IUniversal
//
DECLARE_UNIVERSAL_INTERFACE
// INondelegatingUniversal
//
virtual lresult_t NondelegatingQuery(iid_t iid,void** ppv) {
if (iid == IUniversal::IID) {
*ppv = static_cast<IGameStencil*> (this);
} else if (iid == IGameStencil::IID) {
*ppv = static_cast<IGameStencil*> (this);
} else if (iid == ISystemMngmt::IID) {
// contained component
*ppv = m_pISystemMngmt;
} else {
*ppv = 0;
return lres_e_nointerface;
}
reinterpret_cast<IUniversal*> (*ppv)->retain();
return lres_success;
}
// IGameStencil
//
virtual void update(float dt) {
updating = true;
// TODO:
updating = false;
}
private:
bool updating;
IUniversal * m_pUniversalInner;
ISystemMngmt * m_pISystemMngmt;
};
}; /* namespace ecs */
#endif /* GAME_STENCIL_H */
被聚合的组件 SystemMngmt的代码：
/**
* ISystemMngmt.h
*
* Author: master@pepstack.com
*
* Refer:
* http://www.richardlord.net/blog/what-is-an-entity-framework
* http://blog.csdn.net/i_dovelemon/article/details/30250049
* http://blog.csdn.net/zhao_92221/article/details/46629553
* http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-12
*/
#ifndef ISYSTEM_MNGMT_H
#define ISYSTEM_MNGMT_H
#include "core/SIPtr.h"
namespace ecs {
interface ISystemMngmt : IUniversal
{
static const iid_t IID = ((iid_t) 0x10F001);
virtual void update(float dt) = 0;
virtual void pause() = 0;
virtual void resume() = 0;
};
}; /* namespace ecs */
#endif /* ISYSTEM_MNGMT_H */
/**
* SystemMngmt.h
*
* Refer:
* http://www.richardlord.net/blog/what-is-an-entity-framework
* http://blog.csdn.net/i_dovelemon/article/details/30250049
* http://blog.csdn.net/zhao_92221/article/details/46629553
* http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-13
* Last Updated: 2016-06-13
*/
#ifndef SYSTEM_MNGMT_H
#define SYSTEM_MNGMT_H
#include "ISystemMngmt.h"
#include <memory>
#include <vector>
using namespace std;
namespace ecs {
class SystemMngmt :
public ISystemMngmt,public NondelegatingUniversalImpl
{
public:
// Creation
//
CREATE_INSTANCE_WITH_AGGREGATION(SystemMngmt)
private:
// Constructor
SystemMngmt(IUniversal * pUniversalOuter) :
NondelegatingUniversalImpl(pUniversalOuter) {
paused = false;
printf("SystemMngmt\n");
}
// Destructor
virtual ~SystemMngmt() {
finalRelease();
printf("~SystemMngmt\n");
}
virtual lresult_t init(unsigned threadctx) {
NondelegatingUniversalImpl::init(threadctx);
return lres_success;
}
public:
// IUniversal
//
DECLARE_UNIVERSAL_INTERFACE
// INondelegatingUniversal
//
virtual lresult_t NondelegatingQuery(iid_t iid,void** ppv) {
if (iid == IUniversal::IID) {
*ppv = static_cast<INondelegatingUniversal*> (this);
} else if (iid == ISystemMngmt::IID) {
*ppv = static_cast<ISystemMngmt*> (this);
} else {
*ppv = 0;
return lres_e_nointerface;
}
reinterpret_cast<IUniversal*> (*ppv)->retain();
return lres_success;
}
// ISystemMngmt
//
// Update all the system
void update(float dt) {
}
// Pause all the systems
void pause() {
paused = true;
}
// Resume all the systems
void resume() {
paused = false;
}
private:
bool paused;
};
}; /* namespace ecs */
#endif /* SYSTEM_MNGMT_H */
最后是测试代码：
//
// main.cpp
//
#ifdef WIN32
// Refer:
// http ://www.cnblogs.com/skynet/archive/2011/02/20/1959162.html
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#else
#include <stdlib.h>
#endif
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "model/GameStencil.h"
using namespace ecs;
void usage()
{
SIPtr<IGameStencil> spGame;
GameStencil::createInstance(thread_ctx_single,spGame.iid(),(void**) &spGame);
SIPtr<ISystemMngmt> spSysMngmt;
spGame->query(spSysMngmt.iid(),(void**) &spSysMngmt);
SIPtr<IGameStencil> spGame2;
spSysMngmt->query(spGame2.iid(),(void**) &spGame2);
assert(spGame2.get() == spGame.get());
spSysMngmt->update(0.1f);
}
int main()
{
#ifdef _CRTDBG_MAP_ALLOC
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
printf("main.cpp start\n");
usage();
printf("main.cpp exit.\n");
return 0;
}
没有内存泄露。OK!