Strategy模式的具体实现

看了下，Strategy模式，很是安慰，觉得该模式不用脑子去记了，因为这个模式跟Bridge模式好像是一样的，至少这两个在接收指针对象上的区别我没怎么看出来，但是跟

Template模式相比，我觉得吧，他没有实现算法框架的封装，但是人家说了这也算是设计模式的一种，也就这样了，也许我根本没看懂？？看完这篇只记得一句话，

favor composition over inheritance（组合优于继承），因为继承是一种较强的约束，同时也比较容易暴漏其内部结构，而对象组合，则不存在这样的诟病。

1、策略模式，拥有一个Context类，真实需要功能的类，或者我们可以这样说Context类，需要算法实现的结果而Strategy类则是一个接口，所有需要实现的公开接口都在Strategy中进行定义，而Strategy的具象子类则是根据不同的情况进行对该接口的不同实现！！！！

2、Context中会有一个Strategy的类型指针，根据面对的不同状况去申请不同的具体子类，然后实现具有细微差别的功能！！！！但是这样带来一个问题就是客户端需要了解具体的情况去申请不同的具象子类才行，这就会暴露些许细节！！！这是缺点

#include<iostream>
using namespace std;
class Strategy
{
   public:
    virtual   void AlgrithmInterface()=0;
   Strategy()
    {;}
    ~Strategy()
    {;}
};
class ConcreteStrategy1:public Strategy
{
    public:
    ConcreteStrategy1()
   {;}
   ~ConcreteStrategy1()
   {;}
   public:
   void AlgrithmInterface()
   {
      cout<<"ConcreteStrategy1::AlgrithmInterface\n";
   }
};
class ConcreteStrategy2:public Strategy
{
    public:
    ConcreteStrategy2()
    {;}
    ~ConcretegyStrategy2()
   {;}
    void AlgrithmInterface()
    {
      cout<<"ConcreteStrategy2::AlgrithmInterface\n";
}
};
class Context
{
   private:
   Strategy* m_strategy_ptr;
   public:
   Context(Strategy* tmp)
   {
      m_strategy_ptr=tmp;
   }
   ~Context()
    {
       if(m_strategy_ptr!=NULL)
        {
           delete m_strategy_ptr;
           m_strategy_ptr=NULL;
         }
    }
   void DoAction()
    {
        m_strategy_ptr->AlgrithmInterface();
 }
};
 int main()
{
      Strategy* tmp=new ConcreteStrategy1();
      Context * con=new Context(tmp);
     con->DoAction();
     Strategy* tmp2=new ConcreteStrategy2();
     Context*  con2=new COntext(tmp2);
    con2->DoAction();
    delete con;
    delete con2;
  }