组件系统

从基类派生出新的类时，往往会添加新的方法，当该类的对象以基类指针的形式表现出来的时候，我们就无法调用这些的新的方法了。从概念上来看，是因为行为绑定到类型上，父类自然无法调用子类新的行为。在面向对象编程中，行为与类型耦合的比较紧密。

组件系统将对象与行为解耦，所有对象都表现为组件指针，所有行为都表现为接口指针。通过查询接口来获取行为。所有组件都从工厂类产生。

以下是示例代码，代码是从游戏编程精粹里修改而来。

首先我们需要一个类型标识类，因为当对象都表现为组件指针时，只有依赖类型标识类才能区分。

/*------------------------------------------------------------------
// 著作版权：Copyright (C) liuxb
// 创建时间：[liuxb|20131005]
// 功能描述：类型id
//
// 修改时间：
// 修改描述：
// 
//----------------------------------------------------------------*/

#pragma once

#include <cassert>


// 类型id
class classid
{
public:
    const static unsigned int INVALID_HASH = 0xffffffff; 

public:
    classid(void) { m_hash_value = INVALID_HASH; }
    explicit classid(unsigned int hash_value) : m_hash_value(hash_value) {}
    explicit classid(const char* class_name) { m_hash_value = make_hash(class_name); }
    classid(const classid& rhs) : m_hash_value(rhs.m_hash_value) {}
    
    template<typename Type>
    classid(Type const* type);

    inline classid& operator = (const classid& rhs);
    inline classid& operator = (unsigned int hash_value);

public:
    bool is_valid() { return m_hash_value == INVALID_HASH; }
    operator unsigned int(void) { return m_hash_value; }

    const bool operator<(const classid& rhs) const { return m_hash_value<rhs.m_hash_value; }
    const bool operator<=(const classid& rhs) const { return m_hash_value<=rhs.m_hash_value; }
    const bool operator>(const classid& rhs) const { return m_hash_value>rhs.m_hash_value; }
    const bool operator>=(const classid& rhs) const { return m_hash_value>=rhs.m_hash_value; }
    const bool operator==(const classid& rhs) const { return m_hash_value==rhs.m_hash_value; }
    const bool operator!=(const classid& rhs) const { return m_hash_value!=rhs.m_hash_value; }
    

private:
    inline unsigned int make_hash(const char* class_name);

private:
    unsigned int m_hash_value;
};





inline classid& classid::operator = (const classid& rhs) 
{
    if(&rhs != this) m_hash_value = rhs.m_hash_value;
    return *this;
}

inline classid& classid::operator = (unsigned int hash_value) 
{
    m_hash_value = hash_value;
    return *this;
}

inline unsigned int classid::make_hash(const char* class_name)
{
    const static unsigned int HASH_INIT = 0x811c9dc5;
    const static unsigned int HASH_PRIME = 0x01000193;

    assert(class_name!=0 && class_name[0]!=0);
    const unsigned char* pname = (const unsigned char*)class_name;
    unsigned int hash = HASH_INIT;

    while (*pname)
    {
        hash *= HASH_PRIME;
        hash ^= (unsigned int)(*pname);
        ++pname;
    }
    return hash;
}

template<typename Type>
inline classid::classid(Type const* type)
{
    m_hash_value = make_hash(typeid(Type).name());
}

接下来需要一个接口标识类，用于保存组件里的接口指针。本来类型标识类也足以完成这个功能，但是游戏编程精粹里给接口添加了一个版本号的功能。而我这为了简单就没有使用该类。

/*------------------------------------------------------------------
// 著作版权：Copyright (C) liuxb
// 创建时间：[liuxb|20131006]
// 功能描述：接口标识id
//
// 修改时间：
// 修改描述：
// 
//----------------------------------------------------------------*/

#pragma once

#include "class_version.hpp"
#include "classid.hpp"

struct interfaceid
{
public:
    classid classid;
    int version;

public:
    template<class Type>
    explicit interfaceid(const Type* type)
        : version(version_number(type))
        , classid(type)
    {

    }

public:
    int version_number(...) { return 0; }

    template<int number>
    int version_number(const class_version<number>*)
    {
        return number;
    }

    bool operator==(const interfaceid& iid)
    {
        return    (version == -iid.version || version == iid.version) && classid == iid.classid;
    }


    bool operator<(const interfaceid& iid) const
    {
        if(classid == iid.classid) return version < iid.version;
        return classid < iid.classid;
    }
};



struct interfaceid_withno_version
{
    classid classid;


    template<class Type>
    explicit interfaceid_withno_version(const Type* type)
        :    classid(type)
    {}


    bool operator==(const interfaceid_withno_version& iid)
    {
        return    classid == iid.classid;
    }

    bool operator<(const interfaceid_withno_version& iid) const
    {
        return classid < iid.classid;
    }
};

有了classid,interfaceid类之后就可以写组件基类了。handle_message方法使得对象可以接收以及处理感兴趣的事件。

/*------------------------------------------------------------------
// 著作版权：Copyright (C) liuxb
// 创建时间：[liuxb|20131005]
// 功能描述：组件接口
//
// 修改时间：
// 修改描述：
// 
//----------------------------------------------------------------*/

#pragma once

#include <map>
#include "classid.hpp"
#include "interfaceid.hpp"


// 消息处理函数的返回类型
enum emessage_result
{
    mr_false,
    mr_true,
    mr_ignored,
    mr_error
};


// 前置声明
class ientity;
class message;



// 组件接口
class icompoenent
{
    typedef interfaceid_withno_version                    interfaceid;
    typedef std::map<interfaceid, void*>                interface_map;
public:
    virtual ~icompoenent(void) {};

public:
    virtual emessage_result        handle_message(const ientity* entity, const message& msg) { return mr_ignored; }
    classid            get_classid(void) const { return m_classid; }

    // 添加需要导出的接口指针，用于对象构造时确定需导出的接口指针
    // 
    template<class Type>
    void            expose_interface(Type* type);
    // 查询接口指针
    template<class Type>
    Type*            query_interface();
    
private:
    void            set_classid(const classid& oid) { m_classid = oid; }
    void*            query_interface(const interfaceid& id);
private:
    classid            m_classid;
    interface_map    m_interface_map;
};



template<class Type>
inline void icompoenent::expose_interface(Type* type)
{
    m_interface_map[interfaceid(type)] = type;
}

template<class Type>
inline Type* icompoenent::query_interface()
{
    Type* type = 0;
    return reinterpret_cast<Type*>(query_interface(interfaceid(type)));
}

inline void* icompoenent::query_interface(const interfaceid& id)
{
    interface_map::iterator it = m_interface_map.find(id);
    if(it!=m_interface_map.end()) return it->second;
    return 0;
}

最后一个是工厂类，如果写的更精细一点，应该将create函数模板化，以接受带参数的对象构造函数。这里没有提供，各位可以自行添加。

/*------------------------------------------------------------------
// 著作版权：Copyright (C) liuxb
// 创建时间：[liuxb|20131005]
// 功能描述：工厂
//
// 修改时间：
// 修改描述：
// 
//----------------------------------------------------------------*/

#pragma once

#include <cassert>
#include <list>
#include <map>

#include "classid.hpp"
#include "icompoenent.hpp"

// 工厂类
class factory
{
public:
    virtual        ~factory(void) ;

public:
    static        factory& singleton();

public:
    template<class Type> 
    icompoenent*    create(void);

public:
    template<class Type> 
    void            remove_support(void);

    template<class Type> 
    void            support(void);    

    template<class Type>
    bool            is_supported();

    classid            supported_typeid(unsigned int index);
    unsigned int    number_of_supported_types();

private:
    struct base_constructor
    {
        virtual icompoenent* construct() = 0;
    };

    template<class Type>
    struct constructor : base_constructor
    {
        icompoenent* construct()
        {
            return new Type();
        }
    };

    typedef std::map<classid, base_constructor*> constructor_map;

private:
    base_constructor* find_constructor(const classid& id);

    icompoenent*    create(const classid& id);
    bool            is_supported(const classid& id);
    void            remove_support(const classid& id);

private:
    constructor_map        m_constructor_map;
};



inline factory::~factory()
{
    typedef constructor_map::iterator iterator;
    for(iterator it = m_constructor_map.begin(); it!=m_constructor_map.end(); ++it)
    {
        delete it->second;
    }
}


inline factory& factory::singleton()
{
    static factory    fac;
    return fac;
}




inline icompoenent* factory::create(const classid& id)
{
    base_constructor* constructor = find_constructor(id);
    if(constructor) return constructor->construct();
    return 0;
}


template<class Type>
inline icompoenent* factory::create(void)
{
    Type* type = 0;
    return create(classid(type));
}



inline void factory::remove_support(const classid& id)
{
    constructor_map::iterator it = m_constructor_map.find(id);
    if(it!=m_constructor_map.end())
    {
        delete it->second;
        m_constructor_map.erase(it);
    }
}


template<class Type>
inline void factory::remove_support()
{
    Type* type = 0;
    remove_support(classid(type));
}


template<class Type>
inline void factory::support()
{
    Type* type = 0;
    m_constructor_map[classid(type)] = new constructor<Type>();
}


inline classid factory::supported_typeid(unsigned int index)
{
    constructor_map::iterator it = m_constructor_map.begin();
    assert(index < m_constructor_map.size());

    while(index--) 
    {
        ++it;
    }
    return it->first;
}



inline unsigned int factory::number_of_supported_types()
{
    return m_constructor_map.size();
}


inline bool factory::is_supported(const classid& id)
{
    return find_constructor(id)!=0;
}


template<class Type>
inline bool factory::is_supported()
{
    Type* type = 0;
    return is_supported(classid(type))!=0;
}


inline factory::base_constructor* factory::find_constructor(const classid& id)
{
    constructor_map::iterator it = m_constructor_map.find(id);
    if(it!=m_constructor_map.end()) return it->second;
    return 0;
}

// 让生活变得更美好
#define Factory                factory::singleton()

至此一个简单的组件系统就有了。接下来是测试代码。

// component_system.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "factory.hpp"
#include "interfaceid.hpp"
#include "classid.hpp"
#include "icompoenent.hpp"

#include <string>


struct iname
{
    virtual const char* name() = 0;
};

struct ipos
{
    virtual int length() = 0;
};

struct position : public ipos
{
    int x;
    int y;

    virtual int length() { return x*x + y*y; }
};


class compoenent : public icompoenent, public iname
{
public:
    compoenent()
    {
        expose_interface<ipos>(&m_pos);
        expose_interface<iname>(this);
        m_name = "liuxb";
        m_pos.x = 3;
        m_pos.y = 4;
    }
public:
    const char* name() { return m_name.c_str(); }

private:
    std::string        m_name;
    position        m_pos;
};


int _tmain(int argc, _TCHAR* argv[])
{
    Factory.support<compoenent>();

    icompoenent* pcmp = factory::singleton().create<compoenent>();

    iname* name = pcmp->query_interface<iname>();
    ipos* ppos = pcmp->query_interface<ipos>();


    printf("cmp name = %s\n", name->name());
    printf("cmp length = %d\n", ppos->length());

    return 0;
}