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

淡淡的烟草味﹌ 2022-09-28 13:27 130阅读 0赞

看了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;
    }