COM组件笔记（二）

一、内存资源的何时释放？

在主函数的最后面执行delete pA确实是一个可行的办法。但却不是好办法。因为这样子最终是释放了pA的内存资源，不过却不是“及时”(在pA所指的组件不用时)地释放内存资源。

如果一个程序，所有的资源在不用时都没有及时释放，这个程序在运行中所占用的内存将是巨大的。如何解决这个问题呢?这就需要引用计数技术。

 

二、引用计数的原理

• 引用计数技术就是用来管理对象生命期的一种技术。
• 对象O可能同时被外界A，外界B，外界C引用。也就是说外界A，外界B，外界C可能都在使用对象O。
• 每次当对象被外界引用时，计数器就自增1。
• 每次当外界不用对象时，计数器就自减1。
• 在计数值为零时，对象本身执行delete this，销毁自己的资源。
• 引用计数使得对象通过计数能够知道何时对象不再被使用，然后及时地删除自身所占的内存资源。在第一节当中的实现的IUnknown接口的AddRef与Release就是引用计数的实现方法。

以下是自己基于上一节代码，添加引用计数后的Demo3：

#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <Unknwn.h>
using namespace std;

// {4E22FE4C-FC61-4616-B13E-7AC19186000D}
static const IID IID_IX =
{ 0x4e22fe4c, 0xfc61, 0x4616, { 0xb1, 0x3e, 0x7a, 0xc1, 0x91, 0x86, 0x0, 0xd } };

// {26C7D646-9C25-4C88-AAC5-215FC0569CD5}
static const IID IID_IY =
{ 0x26c7d646, 0x9c25, 0x4c88, { 0xaa, 0xc5, 0x21, 0x5f, 0xc0, 0x56, 0x9c, 0xd5 } };


// 接口IX
interface IX : public IUnknown
{
    virtual void Fx1() = 0;
    virtual void Fx2() = 0;
};

// 接口IY
interface IY : public IUnknown
{
    virtual void Fy1() = 0;
    virtual void Fy2() = 0;
};

// 组件CA
class CA : public IX, public IY {
    //构造和析构
public:
    CA() {
        m_lCount = 0;

        // 构造时，需要自增引用计数
        AddRef();
    }

    virtual ~CA() {
        cout << "我被释放了！" << endl;
    }

public:
    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void** ppv) {
        if (iid == IID_IUnknown) {
            // 如果未知的话，我们一般来说返回先继承的那个接口
            *ppv = static_cast<IX*>(this);
        }
        else if (iid == IID_IX) {
            // 返回IX接口
            *ppv = static_cast<IX*>(this);
        }
        else if (iid == IID_IY) {
            // 返回IY接口
            *ppv = static_cast<IY*>(this);
        }
        else {
            // 查询不到IID，*ppv返回NULL
            *ppv = NULL;
            return E_NOINTERFACE; // 函数返回值返回E_NOINTERFACE，表示调用的组件不支持iid的接口
        }

        AddRef();    //之后会提到

        return S_OK;    // 代表函数成功执行
    }
    virtual ULONG STDMETHODCALLTYPE AddRef() {

        // 简单实现方法
        return ++m_lCount;

        // 多线程编程下采用如下方法，这种方法确保同一时刻只会有一个线程来访问成员变量
        // return InterlockedIncrement(&m_lCount);
    };
    virtual ULONG STDMETHODCALLTYPE Release() {
        // 简单实现方法
        if (--m_lCount == 0) {
            delete this;    // 销毁自己
            return 0;
        }

        return m_lCount;

        // 多线程编程下采用如下方法，这种方法确保同一时刻只会有一个线程来访问成员变量
        /*if (InterlockedDecrement(&m_lCount) == 0) {
            delete this;
            return 0;
        }
        return m_lCount;*/
    };

public:
    virtual void Fx1() {
        cout << "Fx1" << endl;
    }

    virtual void Fx2() {
        cout << "Fx2" << endl;
    }

    virtual void Fy1() {
        cout << "Fy1" << endl;
    }

    virtual void Fy2() {
        cout << "Fy2" << endl;
    }

    // 数据
public:
    long m_IAA;
    long m_IAB;
    long m_IAC;
    long m_lCount;

};

int main(int argc, char* argv[])
{
    HRESULT hr;

    // 创建组件
    CA* pA = new CA();    // 引用计数1

    // 从组件查询IUnknown接口
    IUnknown* pIUnknown = NULL;
    hr = pA->QueryInterface(IID_IUnknown, (void**)&pIUnknown);    // 引用计数2
    if (SUCCEEDED(hr)) {    // 对于HRESULT返回值的判断，一般采用SUCCEEDED

        pA->Release();    // pA不再使用，引用计数=1
        pA = NULL;        // 防止再不小心使用m_pA

        // 从IUnknown查询IX接口
        IX* pIX = NULL;
        hr = pIUnknown->QueryInterface(IID_IX, (void**)&pIX);    // 引用计数2
        if (SUCCEEDED(hr)) {
            // 调用IX接口方法
            pIX->Fx1();
            pIX->Fx2();
        }

        IY* pIY = NULL;
        hr = pIUnknown->QueryInterface(IID_IY, (void**)&pIY);    // 引用计数3
        if (SUCCEEDED(hr)) {
            pIY->Fy1();
            pIY->Fy2();
        }

        if ((void*)pIX != (void*)pIY) {
            cout << "pIX != pIY" << endl;
        }

        if ((void*)pIUnknown != (void*)pIY) {
            cout << "pIUnknown != pIY" << endl;
        }

        if ((void*)pIUnknown != (void*)pIX) {
            cout << "pIUnknown != pIX" << endl;
        }

        pIY->Release();    // pIY不再使用，引用计数2
        pIY = NULL;

        // 从IX查询IY
        IY* pIY2 = NULL;
        hr = pIX->QueryInterface(IID_IY, (void**)&pIY2);    //引用计数3

        pIX->Release();  // pIX不再使用，引用计数2
        pIX = NULL;

        if (SUCCEEDED(hr)) {
            pIY2->Fy1();
            pIY2->Fy2();
        }

        pIY2->Release(); //    pIY2不再使用，引用计数1
        pIY2 = NULL;
    }

    //=====================================
    // 目前引用计数位1，因为pIUnknown还在使用
    //=====================================
    IX* pIX2 = NULL;
    hr = pIUnknown->QueryInterface(IID_IX, (void**)&pIX2);
    if (SUCCEEDED(hr)) {
        IX* pIX3 = NULL;
        pIX3 = pIX2;    // 执行了赋值
        pIX3->AddRef();    // 由于上一句执行了赋值，所以引用计数需要自增，引用计数为3

        pIX3->Fx1();
        pIX3->Fx2();

        pIX3->Release();    // pIX3不再使用，引用计数为2
        pIX3 = NULL;
    }
    pIX2->Release();        // pIX2不再使用，引用计数为1
    pIX2 = NULL;

    pIUnknown->Release();    // pIUnknown不再使用，引用计数为0，Release函数里执行了delete this
    pIUnknown = NULL;

    // delete pA; 不需要再调用

    getchar();
    return 0;
}

这里需要注意AddRef函数和Release的意义和其使用的时机：

• AddRef，使组件的引用计数自增1。
• 在返回之前调用AddRef。比如组件的构造函数，QueryInterface函数。
• 在赋值之后调用AddRef比如pIX3 = pIX2，这时需要pIX3->AddRef();

  ---

• Release，使组件引用计数自减1，如果引用计数为零释放本身的内存资源。
• 在接口使用完之后，调用Release。
• 查看Section2Demo1，关于AddRef 与Release的使用,并适当注释一些AddRef或Release查看CA的析构函数是否运行或会不会出现对无效指针(野指针)的操作。

 

三、引用计数的优化

分析以下代码：

 

if(SUCCEEDED(hr)){
    IX *pIX3 = NULL;
    pIX3 = PIX2;
    PIX3->AddRef();
    
    PIX3->Fx1();
    PIX3->Fx2();

    PIX3->Release();
    PIX3 = NULL;  
}

 

对于pIX3与pIX3来说，他们都是同一个接口，生命周期是一样的，这个接口在一个块中，执行了一次AddRef，一次的Release，其实就相当于这二者都没有执行。是否可以进行优化呢？考虑以下优化：

if(SUCCEEDED(hr)){
    IX *pIX3 = NULL;
    pIX3 = PIX2;
    
    PIX3->Fx1();
    PIX3->Fx2();
}

引用计数优化原则：

一、输入参数原则：

• 输入参数指的是给函数传递某个值的参数。在函数体中将会使用这个值但却不会修改它或将其返回给调用者。在C++中，输入参数实际上就是那些按值传递的参数。

• 对传入函数的接口指针，无需调用AddRef与Release

void Fun(IX *pIX){
    IX *pIX2 = pIX;
    
    // pIX2->AddRef();   //可优化

    pIX2->Fx1();
    pIX2->Fx2();  
    
    // pIX2->Release();  //可优化  
}

 

二、局部变量原则
对于局部复制的接口指针，由于它们只是在函数的生命期内才存在，因此无需调用AddRef与Release