一个精巧的C++类工厂，实现根据类的种类，方法的种类生成实例调用，请您拍砖，多提建议

hatingfarmer 2010-08-10 08:39:39

该代码是我业余时间想到的，目的是根据类的种类，类中方法的种类，生成统一调用接口。
最终目的是可以支持所有的类。下面代码刚写尚未开始优化，请各位贡献您的主意。谢谢。



#include "stdafx.h"

#include <map>

using namespace std;

//设备接口抽象类，定义设备接口

class Device

{

public:

    virtual void print1() = 0;

    virtual void print2() = 0;

public:

    Device(){}

    ~Device(){}

};



//具体设备，Device1

class Device1:public Device

{

public:

     void print1(){    printf("Device1:print1\n");}

     void print2(){    printf("Device1:print2\n");}



public:

    Device1(){}

    ~Device1(){}

};



//具体设备，Device2

class Device2:public Device

{

public:

    void print1(){printf("Device2:print1\n");}

    void print2(){printf("Device2:print2\n");}

    

public:

    Device2(){}

    ~Device2(){}

};



//设备类中方法类型定义

enum FUNTYPE{FUN1,FUN2};



//设备类的种类定义

enum DEVICETYPE{DEVICE1,DEVICE2};



//设备类接口函数指针变量定义

typedef void (Device::*pFUN)();



//设备类结构体

typedef struct

{

    Device * pdevice;    //设备类接口指针

    map<FUNTYPE,pFUN> DeviceFunmap; //设备类对应的成员函数指针和成员函数类型映射

}DEVICESTRUCT;



//生成设备调用的工厂类

class ClassFacotry

{

public:

//导入所有设备的种类和每个设备类的接口函数指针

 static    void LoadClass()

    {

        //生成具体Device1结构1

        DEVICESTRUCT deivestruct1;

                //产生Device1

        deivestruct1.pdevice = new Device1();

                //把Device1的函数指针保存到map

        deivestruct1.DeviceFunmap.insert(pair<FUNTYPE,pFUN>(FUN1,&Device::print1));

        deivestruct1.DeviceFunmap.insert(pair<FUNTYPE,pFUN>(FUN2,&Device::print2));

                //保存Device1结构1到成员map

        devicemap.insert(pair<DEVICETYPE,DEVICESTRUCT>(DEVICE1,deivestruct1));



               //生成具体Device2结构2

        DEVICESTRUCT deivestruct2;

               //产生Device2

        deivestruct2.pdevice = new Device2();

                //把Device1的函数指针保存到map

        deivestruct2.DeviceFunmap.insert(pair<FUNTYPE,pFUN>             (FUN1,&Device::print1));

        deivestruct2.DeviceFunmap.insert(pair<FUNTYPE,pFUN>(FUN2,&Device::print2));

        

                //保存Device1结构1到成员map

        devicemap.insert(pair<DEVICETYPE,DEVICESTRUCT>  (DEVICE2,deivestruct2));

    }



static    void Execute(DEVICETYPE deivetype,FUNTYPE funtype)

    {

        static LoadFlag =false;

        if (false ==LoadFlag)

        {

                      //导入所有设备的种类和每个设备类的接口函数指针

                         //只导入一次

            LoadClass();

            LoadFlag = true;

        }

        //根据设备类型和设备方法类型生成具体设备方法条用

        DEVICESTRUCT deivestruct = (devicemap.find(deivetype))->second;

        Device * pdevice = deivestruct.pdevice;

        DeviceFun = ((deivestruct.DeviceFunmap).find(funtype))->second;



                //具体设备方法条用

        (pdevice->*DeviceFun)();



    }



public:

    ClassFacotry(){}

    ~ClassFacotry(){}



private:

//设备成员函数指针

 static  pFUN DeviceFun;



//设备类结构map

  static map<DEVICETYPE,DEVICESTRUCT> devicemap;

};



//初始化设备成员函数指针

pFUN ClassFacotry::DeviceFun =NULL;



//初始化设备类结构map

map<DEVICETYPE,DEVICESTRUCT> ClassFacotry::devicemap;



int main(int argc, char* argv[])

{

    //调用Device1实例的print1方法

    ClassFacotry::Execute(DEVICE1,FUN1);



    //调用Device2实例的print1方法

    ClassFacotry::Execute(DEVICE2,FUN1);



    //调用Device1实例的print2方法

    ClassFacotry::Execute(DEVICE1,FUN2);

    

    //调用Device2实例的print2方法

    ClassFacotry::Execute(DEVICE2,FUN2);

    return 0;

}

...全文

310 13 打赏收藏举报

写回复

13 条回复

切换为时间正序

当前发帖距今超过3年，不再开放新的回复

发表回复

hatingfarmer 2010-08-10

各位请交流

打赏
举报

回复赞

hatingfarmer 2010-08-10

对于万能工厂的实现，我做了如下优化，各位决定怎么样



#include "stdafx.h"

#include <map>

using namespace std;

//设备接口抽象类，定义设备接口

class Device

{

public:

    virtual void print1() = 0;

    virtual void print2() = 0;

public:

    Device(){}

    ~Device(){}

};



//具体设备，Device1

class Device1:public Device

{

public:

     void print1(){    printf("Device1:print1\n");}

     void print2(){    printf("Device1:print2\n");}



public:

    Device1(){}

    ~Device1(){}

};



//具体设备，Device2

class Device2:public Device

{

public:

    void print1(){printf("Device2:print1\n");}

    void print2(){printf("Device2:print2\n");}

    

public:

    Device2(){}

    ~Device2(){}

};



//##########################################################

//设备类中方法类型定义

enum FUNTYPE{FUN1,FUN2};



//设备类的种类定义

enum DEVICETYPE{DEVICE1,DEVICE2};

//#########################################################



//#######################################################################

//万能接口工厂类宏定义



//=====================================================================

//开始创建工厂类宏定义

#define    BEGIN_CREATE_CLASS(_baseclass)        \

typedef void (_baseclass::*pFUN)();              \

                                                 \

typedef struct                                   \

{                                                \

    _baseclass * pdevice;                        \

    map<FUNTYPE,pFUN> DeviceFunmap;              \

}_baseclass##CLASSSTRUCT;                        \

                                                 \

class _baseclass##Facotry                        \

{                                                \

public:                                          \

 static    void LoadClass()                      \

{                                                

//==============================================================================



//==============================================================================

//开始对象-对象类型映射宏定义

#define  ON_CREATING_CLASS(_derivedclsstype,_derivedclass,_baseclass)           \

do{                                                                             \

    _baseclass##CLASSSTRUCT  deivestruct;                                       \

    deivestruct.pdevice = new _derivedclass##();                                \

    deivestruct.DeviceFunmap.insert(pair<FUNTYPE,pFUN>(FUN1,&Device::print1));  \

    deivestruct.DeviceFunmap.insert(pair<FUNTYPE,pFUN>(FUN2,&Device::print2));  \

    devicemap.insert(pair<DEVICETYPE,_baseclass##CLASSSTRUCT>(_derivedclsstype,deivestruct));\

}while(0);

//==============================================================================



//==============================================================================

//工厂类定义结束

#define    END_CREATE_CLASS(_baseclass)                                \

}                                                                      \

static    void Execute(DEVICETYPE deivetype,FUNTYPE funtype)           \

{                                                                      \

        static LoadFlag =false;                                        \

        if (false ==LoadFlag)                                          \

{                                                                      \

            LoadClass();                                               \

            LoadFlag = true;                                           \

}                                                                      \

                                                                       \

        _baseclass##CLASSSTRUCT deivestruct = (devicemap.find(deivetype))->second;\

        Device * pdevice = deivestruct.pdevice;                        \

        DeviceFun = ((deivestruct.DeviceFunmap).find(funtype))->second;\

                                                                       \

        (pdevice->*DeviceFun)();                                       \

                                                                       \

}                                                                      \

                                                                       \

public:                                                                \

	_baseclass##Facotry(){}                                            \

		~_baseclass##Facotry(){}                                       \

                                                                       \

private:                                                               \

 static  pFUN DeviceFun;                                               \

                                                                       \

  static map<DEVICETYPE,_baseclass##CLASSSTRUCT> devicemap;            \

};                                                                     \

                                                                       \

pFUN _baseclass##Facotry::DeviceFun =NULL;                             \

map<DEVICETYPE,_baseclass##CLASSSTRUCT> _baseclass##Facotry::devicemap;

//==============================================================================



//#################################################################################



//#####################################################################

//实例生成函数定义

#define       ExecuteObjectFunction(__classtype,__funtype,__baseclass)   \

__baseclass##Facotry::Execute(__classtype,__funtype);

//#####################################################################





//#######################################################################

//对象-对象类型映射，隐藏工厂生成过程

BEGIN_CREATE_CLASS(Device);

  ON_CREATING_CLASS(DEVICE1,Device1,Device);

  ON_CREATING_CLASS(DEVICE2,Device2,Device);

END_CREATE_CLASS(Device)

//#######################################################################



int main(int argc, char* argv[])

{

    //调用Device1实例的print1方法

    ExecuteObjectFunction(DEVICE1,FUN1,Device);



    //调用Device2实例的print1方法

    ExecuteObjectFunction(DEVICE2,FUN1,Device);



    //调用Device1实例的print2方法

    ExecuteObjectFunction(DEVICE1,FUN2,Device);

    

    //调用Device2实例的print2方法

    ExecuteObjectFunction(DEVICE2,FUN2,Device);

    return 0;

}

打赏
举报

回复赞

hatingfarmer 2010-08-10

我想如果考虑宏的代码生成功能是可以做到的，不过我觉得是否还有更好的方法，请各位继续支招，讨论就是进步
[Quote=引用 8 楼 babilife 的回复:]
楼主想写个万能接口？

劝楼主不要想了，那是不存在的，你只能针对某一个项目进行最大的优化，万能的东西是不存在的
不过楼主思想值得学习！
[/Quote]

打赏
举报

回复赞

sunlin7 2010-08-10

还行，呵呵~~我眼拙，没有看出来精巧的地方。

打赏
举报

回复赞

至善者善之敌 2010-08-10

楼主想写个万能接口？

劝楼主不要想了，那是不存在的，你只能针对某一个项目进行最大的优化，万能的东西是不存在的
不过楼主思想值得学习！

打赏
举报

回复赞

hatingfarmer 2010-08-10



以上程序运行结果：

Device1:print1  

Device2:print1  

Device1:print2  

Device2:print2

打赏
举报

回复赞

hatingfarmer 2010-08-10

这是一个我项目代码中抽取的一个思想，主要是为了将不同类中的不同方法调用，用一个接口来实现，
我想肯定还有可以优化的地方，请各位提出宝贵意见

打赏
举报

回复赞

maple_zhj 2010-08-10

没看出什么特别的地方。

打赏
举报

回复赞

hatingfarmer 2010-08-10

你好，我声明一下：
我这里的根据类的种类，类中方法的种类，生成统一调用接口，意思是对于不同类，不同方法都采用统一调用接口
[Quote=引用 2 楼 zyq5945 的回复:]
用虚函数就行了吧
[/Quote]

打赏
举报

回复赞

zyq5945 2010-08-10

用虚函数就行了吧

打赏
举报

回复赞

jyh_baoding 2010-08-10

思维不错，帮顶

打赏
举报

回复赞

RobyLTE 2010-08-10

楼主，不知道上面代码是否真是出自楼主之手，如果是，不知道楼主目前从事那行工作，
是否有兴趣考虑工作机会，我们是全球知名的通信设备供应商，为您提供非常好的待遇和空间，不过前提是上述代码真是出自您的
作品。如有兴趣请交流，qq:155170160

打赏
举报

回复赞