有效的使用和设计COM智能指针 ——条款13：必须提前释放COM组件时，别妄想智能指针帮你完成

条款13：必须提前释放COM组件时，别妄想智能指针帮你完成

更多条款请前往原文出处：http://blog.csdn.net/liuchang5

有了智能指针，或许你不会想到要自己手动释放或者增加引用计数了。那么请欣赏一下下面这个函数：

void InSomewhere(IHello *pHello)
{
CComPtr<IHello> spHello = pHello;
spHello->DoSomething();
HRESULT hr =CoCreateInstance(
CLSID_HELLO
NULL,
CLSCTX_INPROC_SERVER,
IID_IHELLO,
(void **)&spHello     //这里可能出现资源泄漏
);
assert(SUCCEED(hr));
spHello->DoOtherthing();
}

你认真的核对了一下IID和指针的类型，发现没有问题。并且CoCreateInstance后面这个assert让你对他的行为信心十足。

但是问题是spHello原来是有所指的。他会释放掉相应接口的引用计数吗？答案是未定义。

对于spHello在非空情况下的取地址操作，在不同智能指针中定义不尽相同。对CComPtr来说，他会在DEBUG的时候出发一个断言，而在RELEASE版本就悄悄的让资源泄漏了。而对于_com_ptr_t而言，无论是在RELASE还是DEBUG版本中它都会偷偷的先释放掉原油资源，而不给外界任何关于这种危险操作的提示。

知道了原因可能你不会太期望用取地址符这种危险的操作了。你可能想到了用前面“条款11：以类型安全的方式创资源和查询接口”所讲述的内容。看看下面这个修改版会不会存在问题。

void InSomewhere(IHello *pHello)
{
CComPtr<IHello> spHello = pHello;
spHello->DoSomething();
spHello.CoCreateInstance( CLSID_HELLO );//这里可能出现资源泄漏
assert(spHello);
spHello->DoOtherthing();
}

问题还是发生了，因为CoCreateInstance仍然只是在DEBUG版本中spHello非空的情况下做了一个断言。而RELEASE中资源就泄漏了。而对于_com_ptr_t来说，仍然是悄悄的先帮你把资源给释放掉。

因此最稳妥的应对策略是，“必须提前释放COM组件时，别妄想智能指针帮你完成”。

void InSomewhere(IHello *pHello)
{
CComPtr<IHello> spHello = pHello;
spHello->DoSomething();
spHello = NULL;             //或者spHello.Release(); 提前释放资源
spHello.CoCreateInstance( CLSID_HELLO );
assert(spHello);
spHello->DoOtherthing();
}

OK，问题解决了。

更有一些情况下我们不知觉的导致了内存泄漏，原因同样是由于你没有手动释放COM组件。假设我们设计了这么一个容器来存放智能指针如下：

template<typename T>
class MyStack
{
public:
MyStack(int nCapacity){
m_pArray = new T[nCapacity]();
m_nCapacity = nCapacity;
m_nTop= 0;
};
~MyStack(){
delete[] m_pArray;
};
void push(T Item){
assert(m_nTop < m_nCapacity);
m_pArray[m_nTop++] = Item;
}
T pop(){
assert(m_nTop > 0);
return m_pArray[--m_nTop];
}
MyStack(const MyStack<T>& otherArray)
{
//deep copy it
};
private:
T *m_pArray;
int m_nTop;
int m_nCapacity;
};

而使用这个MyStack的过程是如下这样的：

MyStack<CComPtr<ICalculator>> g_myStack(1000);
void func()
{
for (int i=0; i<500; i++)
{
CComPtr<ICalculator> spCalculator = NULL;
spCalculator.CoCreateInstance(CLSID_CALCULATOR);
g_myStack.push(spCalculator);
}

...

for (int i=0; i<500; i++)
{
CComPtr<ICalculator> spCalculator = g_myStack.pop();
spCalculator->DoSomething();
}
}

500个CoCreateInstance()这个操作或许会让你觉得有点疯狂。但我仅仅是想让你知道内存泄漏是如何潜在的发生的。

其原因是什么？ 智能指针无法在这种情况下自动帮我们释放掉相应的资源，首先他在全局空间上。如果想等待~MyStack()这个析构函数被调用可能需要等到程序结束。而在pop后我们不应当继续在MyStack中保存智能指针对接口的引用。试想，若之后这个MyStack中的元素永远达不到500个。那么，MyStack后半部分所持有的资源永远无法被释放掉。

因此必须手动释放COM组件时，别妄想智能指针帮你完成，稍微改写一下pop()函数，资源泄漏问题解决了。

template<typename T>
class MyStack
{
public:
....
T pop(){
assert(m_nTop > 0);
T tempArray = m_pArray[--m_nTop];
m_pArray  = NULL;        //或者用 m_pArray.Release();
return  tempArray;
}
private:
....
};

谨记在心，智能指针只是辅助我们管理内存的手段。必须提前释放COM资源时，别妄想智能指针帮你完成。这一节可以结束了。