cc与设计模式基础课程讲义v1.0.4.doc

《cc与设计模式基础课程讲义v1.0.4.doc》由会员分享，可在线阅读，更多相关《cc与设计模式基础课程讲义v1.0.4.doc（128页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、C/C+与设计模式基础课程 传智扫地僧 设计模式基础1设计模式编程基础1.1设计模式前言模式 在一定环境中解决某一问题的方案，包括三个基本元素-问题，解决方案和环境。大白话：在一定环境下，用固定套路解决问题。设计模式（Design pattern） 是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代 码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。学习设计模式的意义 提高职业素养，关注学员在行业的长期发展。“我眼中的设计模式”把

2、简单的问题复杂化（标准版），把环境中的各个部分进行抽象、归纳、解耦合。不是多神秘的东西，我们初学者也能学的会。要有信心。学习设计模式的方法对初学者：积累案例，大于背类图。初级开发人员：多思考、多梳理，归纳总结；尊重事物的认知规律，注意事物临界点的突破。不可浮躁。中级开发人员合适的开发环境，寻找合适的设计模式，解决问题。多应用对经典组合设计模式的大量、自由的运用。要不断的追求。设计模式的分类Gang of Four的“Design Patterns: Elements of Resualbel Software”书将设计模式归纳为三大类型，共23种。 创建型模式 : 通常和对象的创建有关，涉及到

3、对象实例化的方式。（共5种模式) 结构型模式： 描述的是如何组合类和对象以获得更大的结构。(共7种模式)行为型模式： 用来对类或对象怎样交互和怎样分配职责进行描述。(共11种模式)创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：1，工厂方法模式（FactoryMethodPattern）的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。2，抽象工厂模式（AbstractFactoryPattern）的意图是提供一个创建一系列相关或者相互依赖的接口，而无需指定它们具体的类。3，建造者模式（BuilderPattern）的意图是将一个复杂的构建与其表示相分离，使得同样

4、的构建过程可以创建不同的表示。4，原型模式（PrototypePattern）是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。5，单例模式（SingletonPattern）是保证一个类仅有一个实例，并提供一个访问它的全局访问点。结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：6，代理模式（ProxyPattern）就是为其他对象提供一种代理以控制对这个对象的访问。7，装饰者模式（DecoratorPattern）动态的给一个对象添加一些额外的职责。就增加功能来说，此模式比生成子类更为灵活。8，适配器模式（AdapterPattern）是将一个类的接口转换成客户

5、希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。9，桥接模式（BridgePattern）是将抽象部分与实际部分分离，使它们都可以独立的变化。10，组合模式（CompositePattern）是将对象组合成树形结构以表示“部分-整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。11，外观模式（FacadePattern）是为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。12，享元模式（FlyweightPattern）是以共享的方式高效的支持大量的细粒度的对象。行为型模式用来对类或对象怎样交互和怎

6、样分配职责进行描述，主要包含以下11种设计模式：13，模板方法模式（TemplateMethodPattern）使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。14，命令模式（CommandPattern）是将一个请求封装为一个对象，从而使你可用不同的请求对客户端进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。15，责任链模式（ChainofResponsibilityPattern），在该模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配

7、责任。16，策略模式（StrategyPattern）就是准备一组算法，并将每一个算法封装起来，使得它们可以互换。17，中介者模式（MediatorPattern）就是定义一个中介对象来封装系列对象之间的交互。终结者使各个对象不需要显示的相互调用，从而使其耦合性松散，而且可以独立的改变他们之间的交互。18，观察者模式（ObserverPattern）定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。19，备忘录模式（MementoPattern）是在不破坏封装的前提下，捕获一个对象的部状态，并在该对象之外保存这个状态。20，访问者模式（Vi

8、sitorPattern）就是表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。21，状态模式（StatePattern）就是对象的行为，依赖于它所处的状态。22，解释器模式（InterpreterPattern）就是描述了如何为简单的语言定义一个语法，如何在该语言中表示一个句子，以及如何解释这些句子。23，迭代器模式（IteratorPattern）是提供了一种方法顺序来访问一个聚合对象中的各个元素，而又不需要暴露该对象的部表示。1.2设计模式基本原则最终目的：高聚，低耦合1) 开放封闭原则 (OCP,Open For Extensio

9、n, Closed For Modification Principle)类的改动是通过增加代码进行的，而不是修改源代码。2) 单一职责原则 (SRP,Single Responsibility Principle)类的职责要单一，对外只提供一种功能，而引起类变化的原因都应该只有一个。3) 依赖倒置原则 (DIP,Dependence Inversion Principle)依赖于抽象(接口),不要依赖具体的实现(类)，也就是针对接口编程。4) 接口隔离原则 (ISP,Interface Segegation Principle)不应该强迫客户的程序依赖他们不需要的接口方法。一个接口应该只提供

10、一种对外功能，不应该把所有操作都封装到一个接口中去。5) 里氏替换原则 (LSP, Liskov Substitution Principle) 任何抽象类出现的地方都可以用他的实现类进行替换。实际就是虚拟机制，语言级别实现面向对象功能。6) 优先使用组合而不是继承原则(CARP,Composite/Aggregate Reuse Principle)如果使用继承，会导致父类的任何变换都可能影响到子类的行为。如果使用对象组合，就降低了这种依赖关系。7) 迪米特法则(LOD,Law of Demeter)一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如在

11、一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的部实现细节，这样当一个模块部的实现发生改变时，不会影响其他模块的使用。(黑盒原理)案例图开闭原则案例依赖倒转1）2）迪米特法则 1)和陌生人说话2)不和陌生人说话3) 与依赖倒转原则结合 某人和 抽象陌生人说话 让某人和陌生人进行解耦合2创建型模式2.1单例模式 2.2.1概念单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。 GoF对单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问

12、的全局访问方法。2.2.2为什么使用单例模式在应用系统开发中，我们常常有以下需求：- 在多个线程之间，比如初始化一次socket资源；比如servlet环境，共享同一个资源或者操作同一个对象- 在整个程序空间使用全局变量，共享资源- 大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。因为Singleton模式可以保证为一个类只生成唯一的实例对象，所以这些情况，Singleton模式就派上用场了。2.2.3实现单例步骤常用步骤 a) 构造函数私有化b) 提供一个全局的静态方法（全局访问点）c) 在类中定义一个静态指针，指向本类的变量的静态变量指针 2.2.4饿汉式单例和懒汉式单例 懒汉式

13、#include using namespace std;/懒汉式class Singeltonprivate:Singelton()m_singer = NULL;m_count = 0;cout 构造函数Singelton . do endl;public:static Singelton *getInstance()if (m_singer = NULL ) /懒汉式：1 每次获取实例都要判断 2 多线程会有问题m_singer = new Singelton;return m_singer;static void printT()cout m_count: m_count endl;p

14、rivate:static Singelton *m_singer;static int m_count;Singelton *Singelton:m_singer = NULL; /懒汉式 并没有创建单例对象int Singelton:m_count = 0;void main01_1()cout 演示 懒汉式 endl;Singelton *p1 = Singelton:getInstance(); /只有在使用的时候，才去创建对象。Singelton *p2 = Singelton:getInstance();if (p1 != p2)cout 不是同一个对象 endl;elsecout

15、 是同一个对象 printT();p2-printT();system(pause);return ;/俄汉式class Singelton2private:Singelton2()m_singer = NULL;m_count = 0;cout 构造函数Singelton . do endl;public:static Singelton2 *getInstance()/ if (m_singer = NULL )/ / m_singer = new Singelton2;/ return m_singer;static void Singelton2:FreeInstance()if (m

16、_singer != NULL)delete m_singer;m_singer = NULL;m_count = 0;static void printT()cout m_count: m_count endl;private:static Singelton2 *m_singer;static int m_count;Singelton2 *Singelton2:m_singer = new Singelton2; /不管你创建不创建实例，均把实例new出来int Singelton2:m_count = 0;void main()cout 演示 饿汉式 endl;Singelton2 *

17、p1 = Singelton2:getInstance(); /只有在使用的时候，才去创建对象。Singelton2 *p2 = Singelton2:getInstance();if (p1 != p2)cout 不是同一个对象 endl;elsecout 是同一个对象 printT();p2-printT();Singelton2:FreeInstance();Singelton2:FreeInstance();system(pause);2.2.5多线程下的懒汉式单例和饿汉式单例 /1懒汉模式虽然有优点，但是每次调用GetInstance()静态方法时，必须判断/NULL = m_ins

18、tance，使程序相对开销增大。/2多线程中会导致多个实例的产生，从而导致运行代码不正确以及存的泄露。/3提供释放资源的函数讨论: 这是因为C+中构造函数并不是线程安全的。 C+中的构造函数简单来说分两步： 第一步：存分配 第二步：初始化成员变量 由于多线程的关系，可能当我们在分配存好了以后，还没来得急初始化成员变量，就进行线程切换，另外一个线程拿到所有权后，由于存已经分配了，但是变量初始化还 没进行，因此打印成员变量的相关值会发生不一致现象。多线程下的懒汉式问题抛出：#include stdafx.h#include windows.h#include winbase.h#include #

19、include iostreamusing namespace std;class Singeltonprivate:Singelton()count +;coutSingelton构造函数beginnendl;Sleep(1000);coutSingelton构造函数endnendl;private:/防止拷贝构造和赋值操作Singelton(const Singelton &obj) ;Singelton& operator=(const Singelton &obj) ;public:static Singelton *getSingelton()/1懒汉模式虽然有优点，但是每次调用Ge

20、tInstance()静态方法时，必须判断/NULL = m_instance，使程序相对开销增大。/2多线程中会导致多个实例的产生，从而导致运行代码不正确以及存的泄露。/3提供释放资源的函数return single;static Singelton *releaseSingelton()if (single != NULL) /需要判断cout释放资源nendl;delete single;single = NULL;return single;void pirntS() /测试函数printf(Singelton printS test count:%d n, count);privat

21、e:static Singelton *single;static int count;/note 静态变量类外初始化Singelton *Singelton:single = new Singelton();int Singelton:count = 0;int _tmainTTT(int argc, _TCHAR* argv)Singelton *s1 = Singelton:getSingelton();Singelton *s2 = Singelton:getSingelton();if (s1 = s2)coutok.equalendl;elsecoutnot.equalpirntS

22、();Singelton:releaseSingelton();cout hello.pirntS();return ; int _tmain(int argc, _TCHAR* argv)int i = 0; DWORD dwThreadId201, dwThrdParam = 1;HANDLE hThread201; int threadnum = 3;for (i=0; ithreadnum; i+)/hThreadi = (HANDLE)_beginthreadex( NULL, 0, &threadfunc, NULL, 0,&dwThreadIdi );hThreadi = (HA

23、NDLE)_beginthread(&threadfunc, 0 , 0 );if (hThreadi = NULL)printf(begin thread %d error!n, i);break;for (i=0; ithreadnum; i+)WaitForSingleObject( hThreadi, INFINITE );printf(等待线程结束n);for (i=0; ithreadnum; i+)/CloseHandle( hThreadi );Singelton:releaseSingelton();cout hello.printV();/Singelton:getSing

24、elton()-pirntS();void CMy01单例优化Dlg:OnBnClickedButton2()int i = 0; DWORD dwThreadId201, dwThrdParam = 1;HANDLE hThread201; int threadnum = 3;for (i=0; ithreadnum; i+)/hThreadi = (HANDLE)_beginthreadex( NULL, 0, &threadfunc, NULL, 0,&dwThreadIdi );hThreadi = (HANDLE)_beginthread(&threadfunc, 0 , 0 );i

25、f (hThreadi = NULL)TRACE(begin thread %d error!n, i);break;for (i=0; ithreadnum; i+)WaitForSingleObject( hThreadi, INFINITE );TRACE(等待线程结束n);for (i=0; ithreadnum; i+)/CloseHandle( hThreadi );/Singelton:releaseSingelton();TRACE(dddddn);2.2.7程序并发机制扩展阅读程序的并发执行往往带来与时间有关的错误，甚至引发灾难性的后果。这需要引入同步机制。使用多进程与多线程

26、时，有时需要协同两种或多种动作，此过程就称同步（Synchronization）。引入同步机制的第一个原因是为了控制线程之间的资源同步访问，因为多个线程在共享资源时如果发生访问冲突通常会带来不正确的后果。例如，一个线程正在更新一个结构，同时另一个线程正试图读取同一个结构。结果，我们将无法得知所读取的数据是新的还是旧的，或者是二者的混合。第二个原因是有时要求确保线程之间的动作以指定的次序发生，如一个线程需要等待由另外一个线程所引起的事件。为了在多线程程序中解决同步问题，Windows提供了四种主要的同步对象，每种对象相对于线程有两种状态信号状态（signal state）和非信号状态（nonsi

27、gnalstate）。当相关联的同步对象处于信号状态时，线程可以执行（访问共享资源），反之必须等待。这四种同步对象是：（1）事件对象（Event）。事件对象作为标志在线程间传递信号。一个或多个线程可等待一个事件对象，当指定的事件发生时，事件对象通知等待线程可以开始执行。它有两种类型：自动重置（auto-reset）事件和手动重置（manual-reset）事件。（2）临界区（Critical Section）。临界区对象通过提供一个进程所有线程必须共享的对象来控制线程。只有拥有那个对象的线程可以访问保护资源。在另一个线程可以访问该资源之前，前一个线程必须释放临界区对象，以便新的线程可以索取对象

28、的访问权。（3）互斥量（Mutex Semaphore）。互斥量的工作方式非常类似于临界区，只是互斥量不仅保护一个进程为多个线程使用的共享资源，而且还可以保护系统中两个或多个进程之间的的共享资源。（4）信号量（Semaphore）。信号量可以允许一个或有限个线程访问共享资源。它是通过计数器来实现的，初始化时赋予计数器以可用资源数，当将信号量提供给一个线程时，计数器的值减1，当一个线程释放它时，计数器值加1。当计数器值小于等于0时，相应线程必须等待。信号量是Windows98同步系统的核心。从本质上讲，互斥量是信号量的一种特殊形式。Windows/NT还提供了另外一种Windows95没有的同步

29、对象：可等待定时器（Waitable Timer）。它可以封锁线程的执行，直到到达某一具体时间。这可以用于后台任务。同步问题是多线程编程中最复杂的问题，后面的linux系统编程中，还会有更深入的介绍。2.2.8总结 在很多人印象中，单例模式可能是23个设计模式中最简单的一个。如果不考虑多线程，的 确如此，但是一旦要在多线程中运用，那么从我们的教程中可以了解到，它涉及到很多编 译器，多线程，C+语言标准等方面的容。本专题参考的资料如下： 1、C+ Primer (Stanley B.Lippman),主要参考的是模板静态变量的初始化以及实例化。 2、 MSDN,有关线程同步interlocked

30、相关的知识。 3、Effective C+ 04条款(Scott Meyers) Non-Local-Static对象初始化顺序以及Meyers 单例模式的实现。 4、Double-Checked Locking,Threads,Compiler Optimizations,and More（Scott Meyers），解释了由于编译器的优化，导致auto_ptr.reset函数不安全，shared_ptr 有类似情况。我们避免使用reset函数。 5、C+全局和静态变量初始化顺序的研究(CSDN)。 6、四人帮的经典之作：设计模式 7、windows 核心编程(Jeffrey Richter

31、) 2.2简单工厂模式2.2.1什么是简单工厂模式 简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。2.2.2模式中包含的角色及其职责1.工厂（Creator）角色简单工厂模式的核心，它负责实现创建所有实例的部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。2.抽象（Product）角色简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。3.具体产品（Concrete Product）角色简单工厂模式所创建的具体实例对象/依赖: 一个类的对象 当另外一个类的函数参数 或者是 返回值3简单

32、工厂模式的优缺点 在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。 2.2.3案例 include iostreamusing namespace std;/思想： 核心思想是用一个工厂，来根据输入

33、的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。/元素分析：/抽象产品类：水果类/具体的水果了：香蕉类、苹果类、梨子/优点 适用于不同情况创建不同的类时/缺点 客户端必须要知道基类和工厂类，耦合性差 增加一个产品，需要修改工厂类class Fruitpublic:virtual void getFruit() = 0;protected:private:;class Banana : public Fruitpublic:virtual void getFruit()cout香蕉endl;protected:private:;class Pear : public Fru

34、itpublic:virtual void getFruit()cout梨子endl;protected:private:;class Factory public:static Fruit* Create(char *name)Fruit *tmp = NULL;if (strcmp(name, pear) = 0)tmp = new Pear();else if (strcmp(name, banana) = 0)tmp = new Banana();elsereturn NULL;return tmp;protected:private:;void main41()Fruit *pear

35、 = Factory:Create(pear);if (pear = NULL)coutgetFruit();Fruit *banana = Factory:Create(banana);banana-getFruit();system(pause);2.2.4练习主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。GOOD:适用于不同情况创建不同的类时BUG：客户端必须要知道基类和工厂类，耦合性差（工厂类与基类为关联关系）#include iostreamusing namespace st

36、d;/需求：/模拟四则运算；/用操作符工厂类生产操作符（加减乘除）, 进行结果运算/运算符抽象类 COperation/加减乘除具体的类(注意含有2个操作数)/工厂类CCalculatorFactory /核心思想 用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果class COperationpublic:int first;int second;public:virtual double GetResult() = 0;private:;class AddOperation : public COperationpublic:double GetResult()return first + s