设计模式1：单例模式、工厂模式

文章为以前网上学习总结拼凑出来的

单例模式：

实现单例模式的思路是：一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

// 单例模式范例1（多线程不安全）。 class CSingleton { private:          CSingleton(){}                                 // 定义为私有的，不允许构造          CSingleton( const CSingleton &singleton) = delete;          CSingleton operator=( const CSingleton &singleton) = delete;          ~ CSingleton(); public:          static CSingleton &GetInstance()    // 可以用Get方法取得一个实例          {                   static CSingleton sigleton;          // 这个实例只存在一份儿                   return sigleton;          } };

 

 

// 单例2 template<typename T> class Singleton { public:          static T& GetInstance()          {                    static T theSingleInstance;     //assumes T has a default constructor                   return theSingleInstance;          } };   class OnlyOne : public Singleton<OnlyOne> { private:          OnlyOne(){}          OnlyOne( OnlyOne &rhs ){}          OnlyOne operator=( OnlyOne &rhs ){}          friend class Singleton<OnlyOne>;             // ? public:          //..rest of interface defined here };

 

 

工厂模式：

1.

class CButton{};                                                       // CButton，所有Button类的基类 class CMaxButton: public CButton {};                  // 具体Button，继承自CButton class CMinButton: public CButton {};                   //   class CFactory { private:          typedef CButton* (*FUN)();                      // 定义函数指针类型   private:          CFactory() {}          CFactory( const CFactory &rhs ) = delete;          CFactory& operator=( const CFactory &rhs ) = delete;   public:          static CFactory& GetInstance()            // 单例，只产生一个工厂          {                    static CFactory factory;                   return factory; }   public:          // 给一个产品注册一个key，在工厂里存放          template< typename T > void Registe( const string &key )          {                    m_products[key] = &CFactory::CreateObj<T>;          }   private:          // 根据模板类型创建不同的Button对象，这个Button是从CButton继承过来的。          template< typename T >static CButton* CreateObj()          {                    return new T();          }   public:          // 从工厂里根据已经注册过的产品的key把产品取出来使用。          CButton* GetButton( const string &key ) {                    map< string, FUN >::iterator it = m_products.find( key );            if( it != m_products.end() )          {                              return( ( *( *it ).second )() );          }            return NULL; }          private:          map< string, FUN > m_products;         // 一个key，对应一个产品 };   // 如何使用 int main( int argc, char *argv[] ) {          CFactory &factory = CFactory::GetInstance();      // 得到工厂的实例          factory.Registe< CMaxButton >( "AXEGD GDLSX GDSLD EHDHL PEYMH" ); // 创建一个CMaxButton对象，并用一个注册码key“AXEGD GDLSX GDSLD EHDHL PEYMH”为它注册，现在这个CMaxButton就在工厂的仓库存放着，可以随时取走。          factory.Registe< CMaxButton >( "DGEDH QSFGR LEJFD QPFHF KEUKD" );  // 工厂可以生产多个相同的产品，但给它们注册不同的注册码          CButton *maxButton = factory.GetButton( “AXEGD GDLSX GDSLD EHDHL PEYMH” );  //根据我的注册码来从工厂仓库里取走我的CMaxButton。 }

 

2.

         假设我们有两种产品接口 Button 和 Border ，每一种产品都支持多种系列，比如 Mac 系列和 Windows 系列。这样每个系列的产品分别是 MacButton,WinButton, MacBorder, WinBorder 。为了可以在运行时刻创建一个系列的产品族，我们可以为每个系列的产品族建立一个工厂 MacFactory和 WinFactory。每个工厂都有两个方法CreateButton 和 CreateBorder 并返回对应的产品，可以将这两个方法抽象成一个接口AbstractFactory。这样在运行时刻我们可以选择创建需要的产品系列。

我们的产品结构是这样的

class Button{};  // Abstract Class

class MacButton: public Button {};

class WinButton: public Button {};

class Border{};  // Abstract Class

class MacBorder: public Border {};

class WinBorder: public Border {};

对应的工厂是这样的

class AbstractFactory { public:          virtual Button* CreateButton() =0;          virtual Border* CreateBorder() =0; };   // Mac工厂，生产Mac类型的不同产品 class MacFactory: public AbstractFactory { public:          MacButton* CreateButton() { return new MacButton; }          MacBorder* CreateBorder() { return new MacBorder; } };   // Win工厂，生产Win类型的不同产品 class WinFactory: public AbstractFactory { public:          WinButton* CreateButton() { return new WinButton; }          WinBorder* CreateBorder() { return new WinBorder; } };

 

那么客户可以根据需要选择 Mac 风格或者 Win 风格来创建 Button 或 Border

// 工厂风格 enum EStyle {          MAC,          WIN };   // 根据要求的不同风格，建立不同的工厂 AbstractFactory *RegisterFactory(EStyle style ) {          switch (style)          {          case MAC:                   return new MacFactory;          case WIN:                   return new WinFactory;          default:                    return NULL;          } }   int main( int argc, char *argv[] ) {          AbstractFactory* factory = NULL;          // 一个工厂壳          factory = RegisterFactory( MAC );          // 建立一个MAC风格的工厂          Button* button = factory->CreateButton();  // 用style风格的工厂来产生style风格的产品          Border* border = factory->CreateBorder(); }

         比较这几个类别，可以发现接口其实只是在定义一个架构，并没有实际的逻辑程式，而要实现接口时，若是还有其他物件需要继承你正要实现的类别时，最好把要实现的类别，定义为抽象类别。

适用性：

         在以下情况可以使用抽象工厂模式，

         一个系统要独立于它的产品的创建、组合和表示时。

         一个系统要由多个产品系列中的一个来配置时。

         当你要强调一系列相关的产品对象的设计以便进行联合使用时。

         当你提供一个产品类库，而只想显示它们的接口而不是实现时。

 

优点：

         1. 具体产品从客户代码中被分离出来

         2. 容易改变产品的系列

         3. 将一个系列的产品族统一到一起创建

 

缺点：

         在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口