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

[hatingfarmer]

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

#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;
}

[RobyLTE]

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

[jyh_baoding]

思维不错，帮顶

[zyq5945]

用虚函数就行了吧

[hatingfarmer]

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

[maple_zhj]

没看出什么特别的地方。

[hatingfarmer]

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

[hatingfarmer]

以上程序运行结果：
Device1:print1  
Device2:print1  
Device1:print2  
Device2:print2

[至善者善之敌]

楼主想写个万能接口？

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

[sunlin7]

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

[hatingfarmer]

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

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

[hatingfarmer]

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

#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]

各位请交流