简单工厂与策略模式的区别

简单工厂c++代码:

// Factory.cpp : Defines the entry point for the console application.
//#include "stdafx.h"
#include <stdio.h>
class AbstractProduct;
class Product1;
class Product2;

 class AbstractProduct
{
public:
 AbstractProduct()
 {

 }

 virtual ~AbstractProduct()
 {

 }
 virtual void UseProduct()=0;
};

class Product1 :public AbstractProduct
{
public:
 Product1()
 {
  printf("Structure Product1\n");
 }
 ~Product1()
 {
  printf("Destory Product1\n");
 }
 
 void UseProduct()
 {
  printf("Use Product1\n");
 }
};

class Product2 :public AbstractProduct
{
public:
 Product2()
 {
  printf("Structure Product2\n");
 }

 ~Product2()
 {
  printf("Destory Product2\n");
 }
 void UseProduct()
 {
  printf("Use Product2\n");
 }
};

class Factory
{
public:
 Factory()
 {
  m_pProduct = NULL;
 }
 ~Factory()
 {
  if (NULL != m_pProduct)
  {
   delete m_pProduct;
   m_pProduct = NULL;
  }
 }
 
public:
 AbstractProduct *m_pProduct;
 void GetProduct(bool bChoseProduct1)
 {
  if (m_pProduct)
  {
   delete m_pProduct;
   m_pProduct = NULL;
  }

  if (bChoseProduct1)//此处在模式内部进行选取适当的类对象；
  {
   m_pProduct = new Product1();
  }
  else
  {
   m_pProduct = new Product2();
  }
 }
};

int main(int argc, char* argv[])
{
 Factory *pFactory = new Factory();
 pFactory->GetProduct(1);
 pFactory->m_pProduct->UseProduct();
 pFactory->GetProduct(0);
 pFactory->m_pProduct->UseProduct();
 if (pFactory)
 {
  delete pFactory;
  pFactory = NULL;
 }

}

策略模式c++代码：

// Strategy.cpp : Defines the entry point for the console application.
#include "stdafx.h"
#include <stdio.h>

class Strategy
{
public:
 Strategy()
 {
  
 }

 virtual ~Strategy()
 {
  
 }

 virtual void UseStrategy()=0;
};

class context
{
public:
 context(Strategy *pstrategy)
 {
  m_pStrategy = pstrategy;
 }

 ~context()
 {

 }
 void UseStrategy()
 {
  if (m_pStrategy)
  {
   m_pStrategy->UseStrategy();
  }
 }

public:
 Strategy *m_pStrategy;
};

class SubStrategyA :public Strategy
{
public:
 SubStrategyA()
 {

 }

 ~SubStrategyA()
 {

 }

public:
 void UseStrategy()
 {
  printf("Use StrategyA\n");
 }
};

class SubStrategyB :public Strategy
{
public:
 SubStrategyB()
 {

 }
 
 ~SubStrategyB()
 {

 }

public:
 
 void UseStrategy()
 {
  printf("Use StrategyB\n");
 }
};

int main(int argc, char* argv[])
{
 //整个策略模式中没有根据条件实例化类对象。实例化对象是调用者选择好了传进去的。
 SubStrategyA *pStrategyA = new SubStrategyA();
 SubStrategyB *pStrategyB = new SubStrategyB();
 context *pcontext1 = new context(pStrategyA);
 pcontext1->UseStrategy();
 context *pcontext2 = new context(pStrategyB);
 pcontext2->UseStrategy();

}

 策略模式和简单工厂模式看起来非常相似，都是通过多态来实现不同子类的选取，这种思想应该是从程序的整体来看得出的。如果从使用这两种模式的角度来看的话，我们会发现在简单工厂模式中我们只需要传递相应的条件就能得到想要的一个对象，然后通过这个对象实现算法的操作。而策略模式，使用时必须首先创建一个想使用的类对象，然后将该对象最为参数传递进去，通过该对象调用不同的算法。在简单工厂模式中实现了通过条件选取一个类去实例化对象，策略模式则将选取相应对象的工作交给模式的使用者，它本身不去做选取工作。