设计模式

Factory method pattern

 

工厂方法模式 是一种面向对象的设计模式。通过调用不同的方法返回需要的类，而不是去实例化具体的类。 对实例创建进行了包装。 工厂方法是一组方法， 他们针对不同条件返回不同的类实例，这些类一般有共同的父类。

工厂方法模式实施一种按需分配的策略， 即传入参数进行选择， 工厂方法根据参数进行选择，返回具体的实例。

 

 

 

 

#include <stdexcept> #include <iostream> #include <memory> class Pizza { public: virtual int getPrice() const = 0; }; class HamAndMushroomPizza : public Pizza { public: virtual int getPrice() const { return 850; } }; class DeluxePizza : public Pizza { public: virtual int getPrice() const { return 1050; } }; class HawaiianPizza : public Pizza { public: virtual int getPrice() const { return 1150; } }; class PizzaFactory { public: enum PizzaType { HamMushroom, Deluxe, Hawaiian }; static Pizza* createPizza(PizzaType pizzaType) { switch (pizzaType) { case HamMushroom: return new HamAndMushroomPizza(); case Deluxe: return new DeluxePizza(); case Hawaiian: return new HawaiianPizza(); } throw "invalid pizza type."; } }; /* * Create all available pizzas and print their prices */ void pizza_information( PizzaFactory::PizzaType pizzatype ) { std::cout << "Price of " << pizzatype << " is " << PizzaFactory::createPizza(pizzatype)->getPrice() << std::endl; } int main () { pizza_information( PizzaFactory::HamMushroom ); pizza_information( PizzaFactory::Deluxe ); pizza_information( PizzaFactory::Hawaiian ); }

 

 

 

 

Abstract factory pattern

 

抽象工厂模式（英语：Abstract Factory）是一种常见的设计模式。此模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对系的系列来创建一个具体的工厂类别。

 

原文链接：http://zh.wikipedia.org/zh-cn/%E6%8A%BD%E8%B1%A1%E5%B7%A5%E5%8E%82

 

 

 

 

假设我们有两种产品接口 Button 和 Border ，每一种产品都支持多种系列，比如 Mac 系列和 Windows 系列。这样每个系列的产品分别是 MacButton, WinButton, MacBorder, WinBorder 。为了可以在运行时刻创建一个系列的产品族，我们可以为每个系列的产品族建立一个工厂 MacFactory 和 WinFactory 。每个工厂都有两个方法 CreateButton 和 CreateBorder 并返回对应的产品，可以将这两个方法抽象成一个接口 AbstractFactory 。这样在运行时刻我们可以选择创建需要的产品系列。 [编辑] C++ 我们的产品结构是这样的 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; }; class MacFactory: public AbstractFactory { public: MacButton* CreateButton() { return new MacButton; } MacBorder* CreateBorder() { return new MacBorder; } }; class WinFactory: public AbstractFactory { public: WinButton* CreateButton() { return new WinButton; } WinBorder* CreateBorder() { return new WinBorder; } }; 那么客户可以根据需要选择 Mac 风格或者 Win 风格来创建 Button 或 Border AbstractFactory* fac; switch (style) { case MAC: fac = new MacFactory; break; case WIN: fac = new WinFactory; break; } Button* button = fac->CreateButton(); Border* border = fac->CreateBorder();

 

 

Builder pattern

 

生成器（英：Builder）是一种设计模式，又名：建造模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

在以下情况使用生成器模式：

• 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时；
• 当构造过程必须允许被构造的对象有不同的表示时。

 

/******************************************************************** created: 2006/07/19 filename: Builder.h author: 李创 http://www.cppblog.com/converse/ purpose: Builder模式的演示代码 *********************************************************************/ #ifndef BUILDER_H #define BUILDER_H // 虚拟基类,是所有Builder的基类,提供不同部分的构建接口函数 class Builder { public: Builder(){}; virtual ~Builder(){} // 纯虚函数,提供构建不同部分的构建接口函数 virtual void BuilderPartA() = 0; virtual void BuilderPartB() = 0; }; // 使用Builder构建产品,构建产品的过程都一致,但是不同的builder有不同的实现 // 这个不同的实现通过不同的Builder派生类来实现,存有一个Builder的指针,通过这个来实现多态调用 class Director { public: Director(Builder* pBuilder); ~Director(); void Construct(); private: Builder* m_pBuilder; }; // Builder的派生类,实现BuilderPartA和BuilderPartB接口函数 class ConcreateBuilder1 : public Builder { public: ConcreateBuilder1(){} virtual ~ConcreateBuilder1(){} virtual void BuilderPartA(); virtual void BuilderPartB(); }; // Builder的派生类,实现BuilderPartA和BuilderPartB接口函数 class ConcreateBuilder2 : public Builder { public: ConcreateBuilder2(){} virtual ~ConcreateBuilder2(){} virtual void BuilderPartA(); virtual void BuilderPartB(); }; #endif /******************************************************************** created: 2006/07/19 filename: Builder.cpp author: 李创 http://www.cppblog.com/converse/ purpose: Builder模式的演示代码 *********************************************************************/ #include "Builder.h" #include <iostream> void ConcreateBuilder1::BuilderPartA() { std::cout << "BuilderPartA by ConcreateBuilder1/n"; } void ConcreateBuilder1::BuilderPartB() { std::cout << "BuilderPartB by ConcreateBuilder1/n"; } void ConcreateBuilder2::BuilderPartA() { std::cout << "BuilderPartA by ConcreateBuilder2/n"; } void ConcreateBuilder2::BuilderPartB() { std::cout << "BuilderPartB by ConcreateBuilder2/n"; } Director::Director(Builder* pBuilder) : m_pBuilder(pBuilder) { } Director::~Director() { delete m_pBuilder; m_pBuilder = NULL; } // Construct函数表示一个对象的整个构建过程,不同的部分之间的装配方式都是一致的, // 首先构建PartA其次是PartB,只是根据不同的构建者会有不同的表示 void Director::Construct() { m_pBuilder->BuilderPartA(); m_pBuilder->BuilderPartB(); } /******************************************************************** created: 2006/07/20 filename: Main.cpp author: 李创 http://www.cppblog.com/converse/ purpose: Builder模式的测试代码 *********************************************************************/ #include "Builder.h" #include <stdlib.h> int main() { Builder* pBuilder1 = new ConcreateBuilder1; Director *pDirector1 = new Director(pBuilder1); pDirector1->Construct(); Builder* pBuilder2 = new ConcreateBuilder2; Director *pDirector2 = new Director(pBuilder2); pDirector2->Construct(); delete pDirector1; delete pDirector2; system("pause"); return 0; }

 

 

 Prototype pattern

 

原型模式是创建型模式的一种,其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”，这个原型是可定制的。

原型模式多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；或者创建值相等，只是命名不一样的同类数据。

 

 

 

/******************************************************************** created: 2006/07/20 filename: Prototype.h author: 李创 http://www.cppblog.com/converse/ purpose: Prototype模式的演示代码 *********************************************************************/ #ifndef PROTOTYPE_H #define PROTOTYPE_H // 虚拟基类,所有原型的基类,提供Clone接口函数 class Prototype { public: Prototype(){} virtual ~Prototype(){} virtual Prototype* Clone() = 0; }; // 派生自Prototype,实现Clone方法 class ConcreatePrototype1 : public Prototype { public: ConcreatePrototype1(); ConcreatePrototype1(const ConcreatePrototype1&); virtual ~ConcreatePrototype1(); virtual Prototype* Clone(); }; // 派生自Prototype,实现Clone方法 class ConcreatePrototype2 : public Prototype { public: ConcreatePrototype2(); ConcreatePrototype2(const ConcreatePrototype2&); virtual ~ConcreatePrototype2(); virtual Prototype* Clone(); }; #endif /******************************************************************** created: 2006/07/20 filename: Prototype.cpp author: 李创 http://www.cppblog.com/converse/ purpose: Prototype模式的演示代码 *********************************************************************/ #include "Prototype.h" #include <iostream> ConcreatePrototype1::ConcreatePrototype1() { std::cout << "construction of ConcreatePrototype1/n"; } ConcreatePrototype1::~ConcreatePrototype1() { std::cout << "destruction of ConcreatePrototype1/n"; } ConcreatePrototype1::ConcreatePrototype1(const ConcreatePrototype1&) { std::cout << "copy construction of ConcreatePrototype1/n"; } Prototype* ConcreatePrototype1::Clone() { return new ConcreatePrototype1(*this); } ConcreatePrototype2::ConcreatePrototype2() { std::cout << "construction of ConcreatePrototype2/n"; } ConcreatePrototype2::~ConcreatePrototype2() { std::cout << "destruction of ConcreatePrototype2/n"; } ConcreatePrototype2::ConcreatePrototype2(const ConcreatePrototype2&) { std::cout << "copy construction of ConcreatePrototype2/n"; } Prototype* ConcreatePrototype2::Clone() { return new ConcreatePrototype2(*this); } /******************************************************************** created: 2006/07/20 filename: Main.cpp author: 李创 http://www.cppblog.com/converse/ purpose: Prototype模式的测试代码 *********************************************************************/ #include "Prototype.h" #include <stdlib.h> int main() { Prototype* pPrototype1 = new ConcreatePrototype1(); Prototype* pPrototype2 = pPrototype1->Clone(); Prototype* pPrototype3 = new ConcreatePrototype2(); Prototype* pPrototype4 = pPrototype3->Clone(); delete pPrototype1; delete pPrototype2; delete pPrototype3; delete pPrototype4; system("pause"); return 0; }

 

 

 

Singleton pattern

 

单例模式，也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

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

单例模式在多线程的应用场合下必须小心使用。如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。 解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

 

// // This version solves the problems of the minimalist Singleton above, // but strictly speaking only in a single-threaded environment, // and use in a multithreaded environment when relying on the ABI // may still pose problems at program termination time. // class Singleton { private: Singleton() {} ~Singleton() {} Singleton(const Singleton &); // intentionally undefined Singleton & operator=(const Singleton &); // intentionally undefined public: static Singleton &getInstance(); }; // Source file (.cpp) Singleton& Singleton::getInstance() { // This local static variable is only instantiated if and when getInstance() is called. // Although the C++ Standard (still ISO/IEC 14882:2003 as of May 2010) does not // describe behaviour in a multithreaded environment, a commonly used C++ ABI provides // a lock around its initialisation (check for __cxa_guard_acquire, __cxa_guard_release), // but it is not clear how this synchronises with object destruction (are the correct // memory fences in place?), and whether objects are correctly destroyed in reverse // order of construction. static Singleton instance; return instance; }