map实现c++中的反射（粗略）

　　看了c#中的反射机制，感觉这个真的好方便啊，然后也想在c++里面实现一个这样的功能，于是在网上看到别人的方法，就是用map来存放类名（字符串）和函数指针，在使用的时候直接用这个字符串来找这个函数指针，执行这个函数。

　　俗话说，心动不如行动，于是我便将之前简单工厂模式的那个例子拿过来修改，将原来的switch判断符号来实例化算法类更改，使用map将‘+’、‘-’、‘*’、‘/’与具体的算法生产函数绑定。

　　做完后，感觉功能是实现了，但是总感觉怪怪的，在添加一个算法的时候，需要添加这个算法的生产函数，而且要更改原来的map添加函数，这样的话就破坏了开放-封闭原则，但是我也想不出来其他的办法，暂且先做这样，等以后再回来研究吧。

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

using namespace std;

class Operate;

typedef Operate* (*createclass)(void);			//函数指针声明  用于指向创建加减乘除生产函数

class Operate									//算法类基类
{
	double NumberA;								//操作数NumberA
	double NumberB;								//操作数NumberB
public:
	void setNumA(double A){NumberA = A;}		//NumberA赋值
	void setNumB(double B){NumberB = B;}		//NumberB赋值
	double getNumA(){return NumberA;}			//获取NumberA值
	double getNumB(){return NumberB;}  			//获取NumberB值
	virtual double getresult()					//虚函数  用于实现多态  实现派生类的getresult()函数		
	{
		double result;
		return result;
	}  
};

class OperateADD : public Operate				//加法算法类
{
	double getresult()
	{
		double result;
		double numA = this->getNumA(); 
		double numB = this->getNumB();
		result = numA + numB;
		return result;
	} 
}; 

class OperateSUB : public Operate				//减法算法类
{
	double getresult()
	{
		double result;
		double numA = this->getNumA(); 
		double numB = this->getNumB();
		result = numA - numB;
		return result;
	}
};

class OperateMUL : public Operate				//乘法算法类
{
	double getresult()
	{
		double result;
		double numA = this->getNumA(); 
		double numB = this->getNumB();
		result = numA * numB;
		return result;
	}
};

class OperateDIV : public Operate				//除法算法类
{
	double getresult()
	{
		double result;
		double numA = this->getNumA();
		double numB = this->getNumB();
		try
		{
			if(numB == 0)						//除数为0时 抛出异常
			{
				throw "除数不能为0！";
			}
			else
			{
				result = numA / numB;
				return result;
			}
		}	
		catch(const char* msg)
		{
			cout<<msg<<endl;
		}
	}
};

Operate* my_ADD()								//加法生产函数
{
	return (new OperateADD);
}

Operate* my_SUB()								//减法生产函数
{
	return (new OperateSUB);
}

Operate* my_MUL()								//乘法生产函数
{
	return (new OperateMUL);
}

Operate* my_DIV()								//除法生产函数
{
	return (new OperateDIV);
}

class IFactory									//算法工厂类
{
	map<string, createclass> m_map;				//map容器 存放算法生产函数的指针
	map<string, createclass>::iterator it;		//map容器迭代器
public:
	IFactory()									//构造函数  将加减乘除符号和算法生产函数指针保存
	{
		m_map.insert(pair<string, createclass>("+",&my_ADD));
		m_map.insert(pair<string, createclass>("-",&my_SUB));
		m_map.insert(pair<string, createclass>("*",&my_MUL));
		m_map.insert(pair<string, createclass>("/",&my_DIV));
	}
	
	Operate* getclassbyname(string str)			//由给定的运算符调用对应的算法生产函数
	{
		it = m_map.find(str);					//查找对应运算符的字段
		if ( it == m_map.end() ) 
		{			
			return NULL ;  
		}
		else 
		{			
			return it->second() ;  
		}
	}
};

int main()
{
	double numA, numB;
	string oper;
	cout<<"请输入数字A：";
	cin>>numA;
	cout<<"请输入运算符(+、-、*、/):";
	cin>>oper;
	cout<<"请输入数字B：";
	cin>>numB;
	
	IFactory* factory = new IFactory();				//定义工厂类
	Operate* ope = factory->getclassbyname(oper);	//由运算符生成算法类
	ope->setNumA(numA);								//设置运算符A
	ope->setNumB(numB);								//设置运算符B
	cout<<ope->getresult()<<endl;					//输出结果
	
	return 0;
}

转载于:https://my.oschina.net/u/3433829/blog/881532