插件框架内核完成

1、所有组件类都支持接口 Ix_Object

//! 对象基本接口
/*! 所有组件类都支持该接口
    \interface Ix_Object
    \ingroup _GROUP_PLUGIN_CORE_
    \see 智能指针类: Cx_Ptr, Cx_Interface
*/
interface Ix_Object
{
    //! 增加引用计数, 由智能指针类调用
    virtual void AddRef() = 0;

    //! 减少引用计数, 自动释放对象, 由智能指针类调用
    virtual void Release() = 0;
};

2、定义一个类来表示组建类ID，这样相对于普通字符串常量而言具有强类型特点，且不是指针

//! 组件类ID
class XCLSID
{
public:
    //! 默认构造函数
    XCLSID();

    //! 给定UUID串构造
    XCLSID(LPCSTR clsid);

    //! 拷贝构造函数
    XCLSID(const XCLSID& src);

    //! 赋值为一个UUID串的操作符函数
    XCLSID& operator=(LPCSTR clsid);

    //! 赋值操作符函数
    XCLSID& operator=(const XCLSID& src);

    //! 相等操作符函数
    bool operator==(const XCLSID& src) const;

    //! 不相等操作符函数
    bool operator!=(const XCLSID& src) const;

    //! 大于操作符函数
    bool operator>(const XCLSID& src) const;

    //! 小于操作符函数
    bool operator<(const XCLSID& src) const;

    //! 返回内部的ID值
    LPCSTR str() const;

    //! 返回是否为非空的UUID串
    bool valid() const;

private:
    char m_clsid[40];
};

3、提供智能指针类 Cx_Interface 和 Cx_Ptr

//! 封装特定接口的智能指针类
/*!
    \ingroup _GROUP_PLUGIN_CORE_
*/
template <class IF_Type>
class Cx_Interface
{
    typedef Cx_Interface<IF_Type> thisClass;
public:
    //! 缺省构造函数
    Cx_Interface();
    //! 从一个接口指针构造
    template <class IF_Type2>
    explicit Cx_Interface(IF_Type2* pInterface);

    //! 从一个智能指针构造
    template <class IF_Type2>
    explicit Cx_Interface(const Cx_Interface<IF_Type2>& pIF);
    //! 拷贝构造函数
    explicit Cx_Interface(const thisClass& src);

    //! 从一个Cx_Ptr对象构造
    explicit Cx_Interface(const Cx_Ptr& src);
    //! 给定组件类ID创建对象实例
    explicit Cx_Interface(const XCLSID& clsid);
    //! 析构函数
    ~Cx_Interface();
    //! 返回对象接口指针
    IF_Type* P() const;
    //! 调用对象接口函数的操作符
    IF_Type* operator->() const;

    //! 拷贝赋值操作符，复制一个接口指针
    template <class IF_Type2>
    thisClass& operator=(IF_Type2* pInterface);

    //! 拷贝赋值操作符，复制一个智能指针
    template <class IF_Type2>
    thisClass& operator=(const Cx_Interface<IF_Type2>& pIF);

    //! 拷贝赋值操作符，复制同类型的智能指针
    thisClass& operator=(const thisClass& src);
    //! 拷贝赋值操作符，复制Cx_Ptr智能指针
    thisClass& operator=(const Cx_Ptr& src);
    //! 返回两个对象指针是否指向相同的对象
    bool operator==(const IF_Type* pInterface) const;
    //! 返回两个对象指针是否指向不同的对象
    bool operator!=(const IF_Type* pInterface) const;
    //! 返回两个对象指针是否指向相同的对象
    bool operator==(const thisClass& src) const;
    //! 返回两个对象指针是否指向不同的对象
    bool operator!=(const thisClass& src) const;

    //! 相当于 IsNotNull 的转换操作符函数
    operator bool() const;

    //! 相当于 IsNull 的转换操作符函数
    bool operator!() const;
    //! 返回是否没有对象
    bool IsNull() const;
    //! 返回是否有对象
    bool IsNotNull() const;
    //! 立即释放对象指针的引用
    /*! 本对象析构时会自动调用本函数，当对象不再被引用时会自动释放
    */
    void ReleaseInterface();
    //! 分离接口指针
    IF_Type* DetachInterface();
    //! 接管一个接口指针
    void AttachInterface(IF_Type* pIF);
    //! 接管一个接口指针
    void AttachInterface(Ix_Object* pIF);
    //! 给定组件类ID创建有本接口的对象实例
    bool Create(const XCLSID& clsid);
private:
    void Unload();
    void Load(IF_Type* pIF);
    bool InternalAddRef(IF_Type* pInterface);
    bool InternalRelease(IF_Type* pInterface);
private:
    IF_Type*    m_pInterface;
};

//! 封装Ix_Object接口的智能指针类
/*!
    \ingroup _GROUP_PLUGIN_CORE_
    \see Cx_Interface
*/
class Cx_Ptr
{
public:
    //! 默认构造函数
    Cx_Ptr();
    //! 从一个接口指针构造
    template <class IF_Type>
    explicit Cx_Ptr(IF_Type* pInterface);

    //! 从一个特定类型的智能指针构造
    template <class IF_Type>
    explicit Cx_Ptr(const Cx_Interface<IF_Type>& pIF);
    //! 拷贝构造函数
    explicit Cx_Ptr(const Cx_Ptr& src);
    //! 给定组件类ID创建对象实例
    explicit Cx_Ptr(const XCLSID& clsid);
    //! 析构函数
    ~Cx_Ptr();
    //! 返回对象接口指针
    Ix_Object* P() const;
    //! 拷贝赋值操作符，复制一个接口指针
    template <class IF_Type>
    Cx_Ptr& operator=(IF_Type* pInterface);

    //! 拷贝赋值操作符，复制一个特定类型的智能指针
    template <class IF_Type>
    Cx_Ptr& operator=(const Cx_Interface<IF_Type>& pIF);
    //! 拷贝赋值操作符，复制同类型的智能指针
    Cx_Ptr& operator=(const Cx_Ptr& src);
    //! 返回两个对象指针是否指向相同的对象
    bool operator==(const Ix_Object* pInterface) const;
    //! 返回两个对象指针是否指向不同的对象
    bool operator!=(const Ix_Object* pInterface) const;
    //! 返回两个对象指针是否指向相同的对象
    bool operator==(const Cx_Ptr& src) const;
    //! 返回两个对象指针是否指向不同的对象
    bool operator!=(const Cx_Ptr& src) const;

    //! 相当于 IsNotNull 的转换操作符函数
    operator bool() const;

    //! 相当于 IsNull 的转换操作符函数
    bool operator!() const;
    //! 返回是否没有对象
    bool IsNull() const;
    //! 返回是否有对象
    bool IsNotNull() const;
    //! 立即释放对象指针的引用
    /*! 本对象析构时会自动调用本函数，当对象不再被引用时会自动释放
    */
    void ReleaseInterface();
    //! 分离接口指针
    Ix_Object* DetachInterface();
    //! 接管一个接口指针
    void AttachInterface(Ix_Object* pIF);
    //! 给定组件类ID创建对象实例
    bool Create(const XCLSID& clsid);
private:
    void Unload();
    void Load(Ix_Object* pIF);
private:
    Ix_Object*    m_pInterface;
};

4、使用下列宏注册组件类

// XBEGIN_DEFINE_MODULE()
//     XDEFINE_CLASSMAP_ENTRY(clsid, cls)
//     XDEFINE_CLASSMAP_ENTRY_Singleton(clsid, cls)
//     XDEFINE_SPECIAL_INTERFACE_ENTRY_Singleton(clsid, iid, cls)
// XEND_DEFINE_MODULE()
//
// XMODULE_INIT(hInstance)
// XMODULE_FREE()

5、测试代码（均通过）：

interface IA
{
    virtual void f1() = 0;
};

interface IB
{
    virtual void f2() = 0;
};

struct CSimple : IA, IB, Ix_Object
{
    void f1() {}
    void f2() {}
    void AddRef() {}
    void Release() {}
};

const XCLSID CLSID_A("986f229c-6a08-4275-9677-895a2460590c");

void TestPtr()
{
    CSimple obj;
    Ix_Object* pObj = &obj;
    IA* pA = &obj;
    IB* pB = &obj;

    Cx_Ptr obj1(pA);                // Cx_Ptr(其他接口的指针)
    Cx_Ptr obj2(pObj);                // Cx_Ptr(Ix_Object*)
    Cx_Ptr obj3(obj1);                // Cx_Ptr(Cx_Ptr)
    obj1 = pB;                        // Cx_Ptr = 其他接口的指针
    obj1 = pObj;                    // Cx_Ptr = Ix_Object*
    obj1 = obj2;                    // Cx_Ptr = Cx_Ptr
    obj3 == pObj;                    // Cx_Ptr == Ix_Object*

    Cx_Interface<IA> pIFA1(pObj);    // Cx_Interface(Ix_Object*)
    Cx_Interface<IA> pIFA2(pA);        // Cx_Interface(同类型接口的指针)
    Cx_Interface<IA> pIFA3(pB);        // Cx_Interface(其他类型接口的指针)
    Cx_Interface<IB> pIFB1(obj1);    // Cx_Interface(Cx_Ptr)
    Cx_Interface<IB> pIFB2(pIFB1);    // Cx_Interface(Cx_Interface) 同类型
    Cx_Interface<IB> pIFB3(pIFA1);    // Cx_Interface(Cx_Interface) 其他类型
    pIFA1 = pObj;                    // Cx_Interface = Ix_Object*
    pIFA1 = pA;                        // Cx_Interface = 同类型接口的指针
    pIFA1 = pB;                        // Cx_Interface = 其他类型接口的指针
    pIFA1 = obj1;                    // Cx_Interface = Cx_Ptr
    pIFA1 = pIFA2;                    // Cx_Interface = Cx_Interface 同类型
    pIFA1 = pIFB2;                    // Cx_Interface = Cx_Interface 其他类型
    pIFA1 == pA;                    // Cx_Interface == 同类型接口的指针

    Cx_Ptr obj4(pIFA1);                // Cx_Ptr(Cx_Interface)
    obj1 = pIFA1;                    // Cx_Ptr = Cx_Interface

    Cx_Ptr obj5(CLSID_A);            // Cx_Ptr(clsid)
    obj5.Create(CLSID_A);            // Cx_Ptr.Create

    Cx_Interface<IB> pIFB5(CLSID_A);    // Cx_Interface(clsid)
    pIFB5.Create(CLSID_A);            // Cx_Interface.Create
}