phymat.nico的专栏

https://blog.csdn.net/weixin_34200628/article/details/89149078

https://blog.csdn.net/zll_0405/article/details/78232358

https://www.cnblogs.com/bianchengniuren/p/10281587.html

https://blog.csdn.net/u012702547/article/details/95309609

#pragma once#ifndef ITERATOR_H #define ITERATOR_H #include #include using namespace std;class Iterater; // 容器的抽象基类template class Aggregate { public: virtual ~Aggregate(){} virtual

#pragma once//#ifndef _COLLEAGE_H_//#define _COLLEAGE_H_#include using namespace std;class Mediator;class Colleage{public: virtual ~Colleage(); virtual void Aciton() = 0; virtual void Set

#pragma once#ifndef MEMENTO_H #define MEMENTO_H #include typedef std::string State; class Memento; class Originator { public: Originator(const State& rState); Originator(); ~Origi

#pragma once#ifndef OBSERVER_H #define OBSERVER_H #include typedef int STATE; class Observer; //发布者// Subject 抽象基类,只需要知道Observer 基类的声明就可以了 class Subject { public: Subject() : m_nSubj

#pragma once#ifndef STATE_H #define STATE_H class State; class Context { public: Context(State* pState); ~Context(); void Request(); void ChangeState(State *pState); private: Sta

#pragma once#ifndef STRATEGY_H #define STRATEGY_H class Strategy; class Context { public: Context(Strategy *pStrategy); ~Context(); void ContextInterface(); private: Strategy* m_pS

#pragma once// 抽象基类,定义 法的轮廓 class AbstractClass { public: AbstractClass(){} virtual ~AbstractClass(){} // 这个函数中定义了 法的轮廓 void TemplateMethod(); protected: // 纯虚函数,由派生类实现之 virtual vo

#pragma once#ifndef VISITOR_H #define VISITOR_H class Visitor; class Element { public: virtual ~Element(){} virtual void Accept(Visitor &rVisitor) = 0; protected: Element(){} }; cl

#pragma once#ifndef ABSTRACTFACTORY_H #define ABSTRACTFACTORY_H // 抽象基类AbstractProductA,代表产品A 的抽象 class AbstractProductA { public: AbstractProductA() {} virtual ~AbstractProductA(){}; };

#pragma once#ifndef BUILDER_H #define BUILDER_H #include using namespace std;// 虚拟基类,是所有Builder的基类,提供不同部分的构建接口函数 class Builder { public: Builder(){}; virtual ~Builder(){} // 纯虚函数,提供构

#pragma once#ifndef FACTORY_H #define FACTORY_H class Product { public: Product(){} virtual ~Product(){} }; class ConcreateProduct : public Product { public: ConcreateProduct(); v

#pragma once#include #include #include using namespace std;class cloneable{public: virtual cloneable* clone() = 0;};class work_experience:public cloneable{public: cloneable* clone() {

#pragma once#ifndef SINGLETON_H #define SINGLETON_H #include using namespace std;class Singleton { private: Singleton(){}; public: // 静态成员函数,提供全局访问的接口 static Singleton* GetInstancePtr()

#pragma once#ifndef ADAPTER_H #define ADAPTER_H // 需要被Adapt 的类 class Target { public: Target(){} virtual ~Target() {} virtual void Request() = 0; }; // 与被Adapt 对象提供不兼容接口的类 class Ada

#pragma once#ifndef BRIDEG_H #define BRIDEG_H class Implementor; // 维护一个Implementor 类的指针 class Abstraction { public: Abstraction(Implementor* pImplementor); virtual ~Abstraction(); vo

#pragma once#include // 组合中的抽象基类 class Component { public: Component(){} virtual ~Component(){} // 纯虚函数,只提供接口,没有默认的实现 virtual void Operation() = 0; // 虚函数,提供接口,有默认的实现就是什么都不做 virtu

#pragma once#ifndef DECORATOR_H #define DECORATOR_H // 抽象基类,定义一个对象接口,可以为这个接口动态的添加职责. class Component { public: Component(){} virtual ~Component(){} // 纯虚函数,由派生类实现 virtual void Operat

#ifndef _FACADE_H_ #define _FACADE_H_#include "stdafx.h"class Subsystem1 {

#pragma once#ifndef PROXY_H #define PROXY_H // 定义了Proxy 和RealSubject 的公有接口, // 这样就可以在任何需要使用到RealSubject 的地方都使用Proxy. class Subject { public: Subject(){} virtual ~Subject(){} virtual v

#pragma once#ifndef FLYWEIGHT_H #define FLYWEIGHT_H #include #include typedef std::string STATE; class Flyweight { public: virtual ~Flyweight(){} STATE GetIntrinsicState(); virtua

#pragma once#ifndef CHAINOFRESPONSIBILITY_H #define CHAINOFRESPONSIBILITY_H #include // 抽象基类,定义一个处理请求的接口 class Handler { public: Handler(Handler *pSuccessor = NULL); virtual ~Handler()

#pragma once#ifndef COMMAND_H #define COMMAND_H class Command { public: virtual ~Command() {} virtual void Execute() = 0; }; class Receiver { public: void Action(); }; class Invo

#pragma once#include using namespace std;class Context //表述内容{public: Context(); ~Context();protected:private:};class AbstractExpression //抽象表达式{public: virtual ~AbstractExpression();

大家都知道，设计模式分3类23种，创建型5种，结构型7种，行为型11种。创建型，字面意思就是用于创建对象的，我们只要创建一个全局共享的对象，比如对模块接口的封装，那么就用单例模式；我们要创建很多个对象，就用工厂方法，一个具体的工厂接口创建对象；我们要创建一组相关的对象，就用抽象工厂，将创建各种对象的工厂抽象出来；我们要通过一个原型创建对象，并拷贝原型中的内容到新创建的对象中呢，那就用原型模式；