反射1--[c++ 宏定义 ## 的使用]

main.cpp

#include <iostream>
#include "register.h"
#include "registerfun.h"

using namespace std;


int main()
{
    //1.使用##创建对象,创建同类，不同对象
    cout << "1." <<endl;
    Init();
    Create("CObjectA");
    Create("CObjectA");
    Create("CObjectB");
    
    //2.使用##调用对象函数
    cout << "2." <<endl;
    InitFun();
    CallFun("Welcome1");
    CallFun("Welcome2");

    return 0;
}

register.h

#ifndef _REGISTER_H_
#define _REGISTER_H_

#include <iostream>
#include <string>

#include "instance.h"

extern"C" bool Init(void);
extern"C" bool Clear();
extern"C" IObj* Create(const string& name);

#endif

register.cpp

#include "register.h"

#include <iostream>
#include <string>
#include <map>

using namespace std;

//宏定义的一种用法，可实现类似反射的 c++ 功能。宏定义的神奇，减少代码量，类似泛型的感觉
#define IMPLEMENT_CREATE_OBJ(classname)
    static IObj* _create_obj##classname()
    {
        return new classname();
    }
#define CREATE_OBJ_FUN(classname) _create_obj##classname

//函数指针
typedef IObj* (*FCreateObj)(void);
//函数指针的map类型
typedef map<string, FCreateObj> StrCreateFunMap;

//通过宏定义实现各种函数指针
IMPLEMENT_CREATE_OBJ(CObjectA)
IMPLEMENT_CREATE_OBJ(CObjectB)

//定义一个函数指针的map
StrCreateFunMap g_strCreateFunMap;

bool Init(void)
{
    g_strCreateFunMap["CObjectA"] = CREATE_OBJ_FUN(CObjectA);
    g_strCreateFunMap["CObjectB"] = CREATE_OBJ_FUN(CObjectB);
    return true;
}

bool Clear()
{
    return true;
}

IObj* Create(const string& name)
{
    return (*(g_strCreateFunMap[name]))();
}

registerfun.h

#ifndef _REGISTER_FUN_H_
#define _REGISTER_FUN_H_

#include <iostream>
#include <string>
#include <map>

#include "instance.h"

using namespace std;

extern"C" bool InitFun(void);
extern"C" bool ClearFun(void);
extern"C" bool CallFun(const string& name);

#endif

registerfun.cpp

#include "registerfun.h"

#include <iostream>
#include <string>
#include <map>

using namespace std;

#define IMPLEMENT_CALL_FUN(funname)
    static void _call_instance##funname()
    {
        CInstance* p = CInstance::GetInstance();
        p->funname();
    }
#define CALL_FUN(funname) _call_instance##funname

typedef void(*FCallFun)(void);
typedef map<string, FCallFun> StrCallFunMap;

IMPLEMENT_CALL_FUN(Welcome1)
IMPLEMENT_CALL_FUN(Welcome2)

StrCallFunMap g_strCallFunMap;

bool InitFun()
{
    g_strCallFunMap["Welcome1"] = CALL_FUN(Welcome1);
    g_strCallFunMap["Welcome2"] = CALL_FUN(Welcome2);
    return true;
}

bool ClearFun()
{
    return true;
}

bool CallFun(const string& name)
{
    (*(g_strCallFunMap[name]))();
    return true;
}

instance.h

#ifndef _INSTANCE_H_ 
#define _INSTANCE_H_

#include <iostream>
#include <string>

using namespace std;

class IObj
{
public:
    virtual void Welcome()=0;
};
class CObjectA : public IObj
{
public:
    CObjectA();
    virtual ~CObjectA();
    void Welcome();
};
class CObjectB : public IObj
{
public:
    CObjectB();
    virtual ~CObjectB();
    void Welcome();
};
class CInstance
{
private:
    CInstance();
    virtual ~CInstance();
public:
    static CInstance* GetInstance();
    void Welcome1();
    void Welcome2();
private:
    static CInstance* m_pInstance;
};

#endif

instance.cpp

#include "instance.h"

//
CObjectA::CObjectA()
{
    Welcome();
}
CObjectA::~CObjectA()
{
}
void CObjectA::Welcome()
{
    cout << "CObjectA welcome " << this <<endl;
}

//
CObjectB::CObjectB()
{
    Welcome();
}
CObjectB::~CObjectB()
{
}
void CObjectB::Welcome()
{
    cout << "CObjetcB Welcome " << this <<endl;
}

//静态私有类成员变量赋值
CInstance* CInstance::m_pInstance = NULL;
CInstance::CInstance() 
{
}
CInstance::~CInstance()
{
}
CInstance* CInstance::GetInstance()
{
    if (m_pInstance == NULL) {
        m_pInstance = new CInstance();
    }
    return m_pInstance;
}
void CInstance::Welcome1()
{
    cout << "CInstance Welcome1"<<endl;
}
void CInstance::Welcome2()
{
    cout << "CInstance Welcome2"<<endl;
}