[C++][设计模式]介绍

1.设计模式
- 1.何为设计模式？
- 2.深入理解面向对象
- 3.软件设计的目标
- 4.三大模式及其特点
- 5.设计模式分类
2.面向对象设计原则
- 1.为什么要面向对象
- 2.重新认识面向对象
- 3.面向对象设计原则
- 4.C++对象模型
3.重构
- 1. 重构获得模式(Refactoring to Patterns)
- 2.重构关键技法
4.代码感受
- 1.代码一
- - 1.shape.h
  - 2.MainForm.cpp
- 2.代码二
- - 1.shape.h
  - 2.MainForm.cpp
5.总结
- 1.什么时候不用模式？
- 2.经验之谈

1.设计模式

1.何为设计模式？

每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心
这样，你就能一次又一次地使用该方案而不必做重复劳动

2.深入理解面向对象

向下：面向对象三大机制
- 封装：隐藏内部实现
- 继承：复用现有代码
- 多态：改写对象行为
向上：深刻把握面向对象机制所带来的抽象意义，理解如何使用这些机制来表达世界

3.软件设计的目标

复用

4.三大模式及其特点

创建型模式：抽象了实例化过程，它们帮助一个系统独立于如何创建、组合和表示它的那些对象
结构型模式：涉及到如何组合类和对象以获得更大的结构。创建型模式关注一个类或对象的实例化；结构型模式关注多个类或对象组合成更复杂的对象，是为了更灵活的构造对象
行为模式：涉及到算法和对象间职责的分配，不仅描述对象和类的模式，还描述它们之间的通信模式。使用继承机制在类间分派行为

5.设计模式分类

组件协作：现代软件专业分工之后的第一个结果是“框架与应用程序的划分”，“组件协作”模式通过晚期绑定，来实现框架与应用程序之间的松耦合，是二者之间协作时常用的模式
- Template Method
- Strategy
- Observer / Event
单一职责：在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任
- Decorator
- Bridge
对象创建：绕开“new”来避免对象创建(new)过程中所导致的紧耦合(编译时依赖具体实现类)，从而支持对象创建的稳定。它是接口抽象之后的第一步工作
- Factory Method
- Abstract Factory
- Prototype
- Builder
对象性能：面向对象很好地解决了“抽象”的问题，但是不可避免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理
- Singleton
- FlyWeight
接口隔离：在组件构建过程中，某些接口之间直接的依赖常常会带来很多问题、甚至根本无法实现。采用添加一层间接(稳定)(微观上比如指针，宏观上比如操作系统、虚拟机、依赖倒置原则)接口，来隔离本来互相紧密关联的接口是一种常见的解决方案
- Facade
- Proxy
- Mediator
- Adapter
状态变化：在组件构建过程中，某些对象的状态经常会变化，如何对这些变化进行有效地管理？同时又维持高层模块的稳定？
- Memento
- State
数据结构：一些组件在内部具有特定的数据结构，如果让客户程序依赖这些特定的数据结构，将极大地破坏组件的复用。将这些特定数据结构封装在内部，在外部提供统一的接口，来实现与特定结构无关的访问，是一种行之有效的解决方案
- Composite
- Iterator
- Chain of Responsity
行为变化：在组件的构建过程中，组件行为的变化经常导致组件本身剧烈的变化。“行为变化”模式将组件的行为和组件本身进行解耦，从而支持组件行为的变化，实现两者之间的松耦合
- Command
- Visitor
领域问题：在特定领域中，某些变化虽然频繁，但可以抽象为某种规则。这时候，结合特定领域，将问题抽象为语法规则，从而给出在该领域下的一般性解决方案
- Interpreter
现代较少用的模式
- Builder
- Mediator
- Memento
- Iterator
- Chain of Resposibility
- Command
- Visitor
- Interpreter

2.面向对象设计原则

1.为什么要面向对象

变化是复用的天敌
面向对象设计最大的优势：抵御变化

2.重新认识面向对象

理解隔离变化
- 从宏观层面来看，面向对象的构建方式更能适应软件的变化，能将变化所带来的影响减为最小
各司其职
- 从微观层面来看，面向对象的方式更强调各个类的“责任”
- 由于需求变化导致的新增类型不应该影响原来类型的实现 —— 是所谓各负其责
对象是什么？
- 从语言实现层面来看，对象封装了代码和数据
- 从规格层面讲，对象是一系列可被使用的公共接口
- 从概念层面讲，对象是某种拥有责任的抽象

3.面向对象设计原则

依赖倒置原则(DIP)
- 高层模块(稳定)不应该依赖于低层模块(变化)，二者都应该依赖于抽象(稳定)
- 抽象(稳定)不应该依赖于实现细节(变化) ，实现细节应该依赖于抽象(稳定)
- 面向接口编程，依赖于抽象而不依赖于具体
  - 写代码时用到具体类时，不与具体类交互，而是与具体类的上层接口交互
开放封闭原则(OCP)
- 对扩展开放，对更改封闭
- 类模块应该是可扩展的，但是不可修改
  - 在程序需要进行拓展的时候不能去修改原有的代码，而是拓展原有代码，实现热插拔的效果
单一职责原则(SRP)
- 一个类应该仅有一个引起它变化的原因
  - 也就是说每个类应该实现单一的职责
  - 如若不然，就应该把类拆分
- 变化的方向隐含着类的责任
替换原则(LSP)
- 子类必须能够替换它们的基类(IS-A) --> 面向对象设计的基本原则之一
  - 任何基类可以出现的地方，子类一定可以出现
  - 它是继承复用的基石，只有当衍生类可以替换掉基类，软件单位功能不受到影响的时候，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为
- 继承表达类型抽象，是对“开闭原则”的补充
  - 实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以替换原则是对实现抽象化的具体步骤的规范
接口隔离原则(ISP)
- 不应该强迫客户程序依赖它们不用的方法
- 接口应该小而完备
- 每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分
  - 使用多个隔离的接口，比使用单个接口要好
优先使用对象组合，而不是类继承
- 类继承通常为“白箱复用”，对象组合通常为“黑箱复用”
- 继承在某种程度上破坏了封装性，子类父类耦合度高
- 而对象组合则只要求被组合的对象具有良好定义的接口，耦合度低
封装变化点
- 使用封装来创建对象之间的分界层，让设计者可以在分界层的一侧进行修改，而不会对另一侧产生不良的影响，从而实现层次间的松耦合
针对接口编程，而不是针对实现编程
- 不将变量类型声明为某个特定的具体类，而是声明为某个接口
- 客户程序无需获知对象的具体类型，只需要知道对象所具有的接口
- 减少系统中各部分的依赖关系，从而实现“高内聚、松耦合”的类型设计方案

4.C++对象模型

一般都会用第三个对象模型，第三种是比较松的耦合，具有高灵活性

3.重构

1. 重构获得模式(Refactoring to Patterns)

面向对象设计模式是“好的面向对象设计”，所谓“好的面向对象设计”指是那些可以满足 “应对变化，提高复用”的设计
现代软件设计的特征是“需求的频繁变化”
- 设计模式的要点是 “寻找变化点，然后在变化点处应用设计模式，从而来更好地应对需求的变化”
- “什么时候、什么地点应用设计模式”比“理解设计模式结构本身”更为重要
设计模式的应用不宜先入为主，一上来就使用设计模式是对设计模式的最大误用
- 没有一步到位的设计模式
- 敏捷软件开发实践提倡的“Refactoring to Patterns”是目前普遍公认的最好的使用设计模式的方法

2.重构关键技法

静态 --> 动态
早绑定 --> 晚绑定
继承 --> 组合
编译时依赖 --> 运行时依赖
紧耦合 --> 松耦合

4.代码感受

1.代码一

1.shape.h

class Point
{
public:
	int x;
	int y;
};

class Line
{
public:
	Point start;
    Point end;

	Line(const Point& start, const Point& end)
    {
        this->start = start;
        this->end = end;
    }
};

class Rect
{
public:
	Point leftUp;
    int width;
	int height;

	Rect(const Point& leftUp, int width, int height)
    {
        this->leftUp = leftUp;
        this->width = width;
		this->height = height;
    }

};

2.MainForm.cpp

class MainForm : public Form 
{
private:
	Point p1;
	Point p2;

	vector<Line> lineVector;
	vector<Rect> rectVector;
public:
	MainForm()
	{
		//...
	}
protected:
	virtual void OnMouseDown(const MouseEventArgs& e);
	virtual void OnMouseUp(const MouseEventArgs& e);
	virtual void OnPaint(const PaintEventArgs& e);
};

void MainForm::OnMouseDown(const MouseEventArgs& e)
{
	p1.x = e.X;
	p1.y = e.Y;

	//...
	Form::OnMouseDown(e);
}

void MainForm::OnMouseUp(const MouseEventArgs& e)
{
	p2.x = e.X;
	p2.y = e.Y;

	if (rdoLine.Checked){
		Line line(p1, p2);
		lineVector.push_back(line);
	}
	else if (rdoRect.Checked){
		int width = abs(p2.x - p1.x);
		int height = abs(p2.y - p1.y);
		Rect rect(p1, width, height);
		rectVector.push_back(rect);
	}

	//...
	this->Refresh();

	Form::OnMouseUp(e);
}

void MainForm::OnPaint(const PaintEventArgs& e)
{
	//针对直线
	for (int i = 0; i < lineVector.size(); i++)
	{
		e.Graphics.DrawLine(Pens.Red,
			lineVector[i].start.x, 
			lineVector[i].start.y,
			lineVector[i].end.x,
			lineVector[i].end.y);
	}

	//针对矩形
	for (int i = 0; i < rectVector.size(); i++)
	{
		e.Graphics.DrawRectangle(Pens.Red,
			rectVector[i].leftUp,
			rectVector[i].width,
			rectVector[i].height);
	}

	//...
	Form::OnPaint(e);
}

2.代码二

1.shape.h

class Shape
{
public:
	virtual void Draw(const Graphics& g) = 0;
	virtual ~Shape() { }
};

class Point
{
public:
	int x;
	int y;
};

class Line: public Shape
{
public:
	Point start;
	Point end;

	Line(const Point& start, const Point& end)
	{
		this->start = start;
		this->end = end;
	}

	//实现自己的Draw，负责画自己
	virtual void Draw(const Graphics& g)
	{
		g.DrawLine(Pens.Red, 
			start.x, start.y,end.x, end.y);
	}

};

class Rect: public Shape
{
public:
	Point leftUp;
	int width;
	int height;

	Rect(const Point& leftUp, int width, int height)
	{
		this->leftUp = leftUp;
		this->width = width;
		this->height = height;
	}

	//实现自己的Draw，负责画自己
	virtual void Draw(const Graphics& g)
	{
		g.DrawRectangle(Pens.Red,
			leftUp,width,height);
	}

};

2.MainForm.cpp

class MainForm : public Form 
{
private:
	Point p1;
	Point p2;

	//针对所有形状
	vector<Shape*> shapeVector;

public:
	MainForm()
	{
		//...
	}
protected:

	virtual void OnMouseDown(const MouseEventArgs& e);
	virtual void OnMouseUp(const MouseEventArgs& e);
	virtual void OnPaint(const PaintEventArgs& e);
};

void MainForm::OnMouseDown(const MouseEventArgs& e)
{
	p1.x = e.X;
	p1.y = e.Y;

	//...
	Form::OnMouseDown(e);
}

void MainForm::OnMouseUp(const MouseEventArgs& e)
{
	p2.x = e.X;
	p2.y = e.Y;

	if (rdoLine.Checked){
		shapeVector.push_back(new Line(p1,p2));
	}
	else if (rdoRect.Checked){
		int width = abs(p2.x - p1.x);
		int height = abs(p2.y - p1.y);
		shapeVector.push_back(new Rect(p1, width, height));
	}

	//...
	this->Refresh();

	Form::OnMouseUp(e);
}

void MainForm::OnPaint(const PaintEventArgs& e){

	//针对所有形状
	for (int i = 0; i < shapeVector.size(); i++){

		shapeVector[i]->Draw(e.Graphics); //多态调用，各负其责
	}

	//...
	Form::OnPaint(e);
}