C++设计模式---策略模式

女爷i 2022-05-27 00:06 191阅读 0赞

定义算法家族，分别封装起来，让他们之间可以相互替换，让算法变化，不会影响到用户。适合类中的成员以方法为主，算法经常变动，简化了单元测试（因为每个算法都有自己的类），可以通过自己的借口单独测试。策略模式和简单工厂模式基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应该使用策略模式。

//策略模式
    class Arithmetic
    {
    public:
    	virtual void Replace() = 0;
    };
    //三种具体的替换算法  
    class Arithmetic_A : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic A" << endl; }
    };
    
    class Arithmetic_B : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic B" << endl; }
    };
    class Arithmetic_C : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic C" << endl; }
    };
    //Cache需要用到替换算法  
    class Cache
    {
    private:
    	Arithmetic * ar;
    public:
    	Cache(Arithmetic *temp) { ar = temp; }
    	~Cache() { delete ar; }
    	void Replace() { ar->Replace(); }
    };
    
    int main()
    {
    	Cache *cache = new Cache(new Arithmetic_A);//暴露了算法的定义  
    	cache->Replace();
    
    	Cache *cache_1 = new Cache(new Arithmetic_B);//暴露了算法的定义  
    	cache_1->Replace();
    
    	Cache *cache_2 = new Cache(new Arithmetic_C);//暴露了算法的定义  
    	cache_2->Replace();
    
    	return 0;
    }

策略模式与工厂模式结合：客户端只需访问Cache类，而不用知道其他任何信息，只需要知道算法的标签就行了，实现了低耦合。

enum CTYPE {RA, RB ,RC};
    //策略模式
    class Arithmetic
    {
    public:
    	virtual void Replace() = 0;
    };
    //三种具体的替换算法  
    class Arithmetic_A : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic A" << endl; }
    };
    
    class Arithmetic_B : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic B" << endl; }
    };
    class Arithmetic_C : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic C" << endl; }
    };
    //Cache需要用到替换算法  
    class Cache
    {
    private:
    	Arithmetic * ar;
    public:
    	Cache(CTYPE temp) 
    	{ 
    		if (temp == RA)
    			ar = new Arithmetic_A();
    		else if (temp == RB)
    			ar = new Arithmetic_B();
    		else if (temp == RC)
    			ar = new Arithmetic_C();
    		else
    			ar = NULL;
    	}
    	~Cache() { delete ar; }
    	void Replace() { ar->Replace(); }
    };
    
    int main()
    {
    	Cache *cache = new Cache(RA);//Cache cache(RA); cache.Replace();
    	cache->Replace();
    	Cache *cache_1 = new Cache(RB);  
    	cache_1->Replace();
    	Cache *cache_2 = new Cache(RC);  
    	cache_2->Replace();
    
    	return 0;
    }

不需要传参数，直接调用指定算法

//策略模式
    class Arithmetic
    {
    public:
    	virtual void Replace() = 0;
    };
    //三种具体的替换算法  
    class Arithmetic_A : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic A" << endl; }
    };
    
    class Arithmetic_B : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic B" << endl; }
    };
    class Arithmetic_C : public Arithmetic
    {
    public:
    	void Replace() { cout << "Arithmetic C" << endl; }
    };
    
    template <class ARI>
    class Cache
    {
    private:
    	ARI ar;
    public:
    	Cache(){}
    	~Cache() {}
    	void Replace() { ar.Replace(); }
    };
    
    int main()
    {
    	Cache<Arithmetic_B> cache; //模板实参
    	cache.Replace();
    	return 0;
    }

策略模式图

![70][]

[70]: /images/20220527/7db585dc09d44d47b5fc31d15aa72f64.png