设计模式

#ifndef __FACTORY__
#define __FACTORY__
#if 1
#include <map>
#include <string>
using namespace std;
template<typename Product, typename ConcreteProduct>
class ConcreteFactory
{
public:
static Product* CreateProduct()
{
return new ConcreteProduct();
}
};

template<typename Product>
class Creator
{
public:
static Creator& Instance()
{
static Creator<Product> m_instance;
return m_instance;
}
public:
typedef Product* (*CreateProductDelegate)();
typedef map<std::string,CreateProductDelegate> MapRegisterCreatorItem;
template<typename ConcreteProduct>
void registerCreator(const std::string &str)
{
m_RegisterConcreteItem[str] = ConcreteFactory<Product,ConcreteProduct>::CreateProduct;
}
void unregisterAllProduct()
{
MapRegisterCreatorItem::iterator itr = m_RegisterConcreteItem.begin();
m_RegisterConcreteItem.clear();
}
Product * createProduct(const std::string &str)
{
MapRegisterCreatorItem::iterator itr = m_RegisterConcreteItem.find(str);
if (m_RegisterConcreteItem.end() != itr)
{
CreateProductDelegate create = itr->second;
if (NULL != create)
{
return create();
}
}
return 0;
}
private:
Creator(){}
Creator(const Creator&){}
~Creator(){}
private:
MapRegisterCreatorItem m_RegisterConcreteItem;
};

#endif
#endif

 

#ifndef __PRODUCT__
#define __PRODUCT__
#include "Common.h"
#include "TObserver.h"

class IProduct:public IObserver
{
public:
virtual void Process() = 0;
virtual ~IProduct()
{
cout<<"Destroy IProduct"<<endl;
}
};

class CProductA: public IProduct
{
public:
virtual int Notify(char *message)
{
if (NULL != message)
{
cout<<"Product A is Notify:"<<message<<endl;
}
return 0;
}
virtual void Process()
{
cout<<"Product A is Process!"<<endl;
}
virtual ~CProductA()
{
cout<<"Destroy ProductA"<<endl;
}
};
class CProductB: public IProduct
{
public:
virtual int Notify(char *message)
{
if (NULL != message)
{
cout<<"Product B is Notify:"<<message<<endl;
}
return 0;
}
virtual void Process()
{
cout<<"Product B is Process!"<<endl;
}
virtual ~CProductB()
{
cout<<"Destroy ProductB"<<endl;
}
};
class CProductC: public IProduct
{
public:
virtual int Notify(char *message)
{
if (NULL != message)
{
cout<<"Product C is Notify:"<<message<<endl;
}
return 0;
}
virtual void Process()
{
cout<<"Product C is Process!"<<endl;
}
virtual ~CProductC()
{
cout<<"Destroy ProductC"<<endl;
}
};
class CProductD: public IProduct
{
public:
virtual int Notify(char *message)
{
if (NULL != message)
{
cout<<"Product D is Notify:"<<message<<endl;
}
return 0;
}
virtual void Process()
{
cout<<"Product D is Process!"<<endl;
}
virtual ~CProductD()
{
cout<<"Destroy ProductD"<<endl;
}
};
#endif

 

#pragma once
#include "Common.h"
//观察者
class IObserver
{
public:
IObserver(){}
virtual ~IObserver(){}
public:
virtual int Notify(char *message) = 0;
protected:
private:
};
//目标
class ISubject
{
public:
ISubject(){}
virtual ~ISubject(){}
public:
virtual int Notify(char *message)
{
list<IObserver*>::iterator itr = m_observer.begin();
for (; itr != m_observer.end(); itr++)
{
(*itr)->Notify(message);
}
return 0;
}
int Attach(IObserver *obj)
{
m_observer.push_back(obj);
return 0;
}
int Detach(IObserver *obj)
{
m_observer.remove(obj);
return 0;
}
private:
list<IObserver*> m_observer;
};

// Protocol.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Product.h"
#include "TSingletons.h"
#include "TFactory.h"
#include "Common.h"
int _tmain(int argc, _TCHAR* argv[])
{
printf("argc:%d\n",argc);
for (int i =0; i < argc; i++)
{
wprintf(_T("argv:%s\n"),argv[i]);
}
//模板工厂模式
typedef Creator<IProduct> ProductCreateor;
ProductCreateor &factory = ProductCreateor::Instance();
factory.registerCreator<CProductA>("ProductA");
factory.registerCreator<CProductB>("ProductB");
factory.registerCreator<CProductC>("ProductC");
factory.registerCreator<CProductD>("ProductD");
IProduct *productA = factory.createProduct("ProductA");
productA->Process();
IProduct *productB = factory.createProduct("ProductB");
productB->Process();
IProduct *productC = factory.createProduct("ProductC");
productC->Process();
factory.unregisterAllProduct();
//观察者模式
static ISubject s = TSingletons<ISubject>::Instance();
s.Attach((IObserver*)productA);
s.Attach((IObserver*)productB);
s.Attach((IObserver*)productC);
s.Notify("haha");
s.Detach((IObserver*)productA);
s.Detach((IObserver*)productB);
s.Detach((IObserver*)productC);
delete productA;
delete productB;
delete productC;
system("Pause");
return 0;
}