23种设计模式的C++实现、简介、要点

最新推荐文章于 2024-08-05 11:45:40 发布

来份西红柿炒番茄

最新推荐文章于 2024-08-05 11:45:40 发布

阅读量446

点赞数

分类专栏：设计模式文章标签：设计模式 C++ 类接口

本文链接：https://blog.csdn.net/weixin_43961107/article/details/107133682

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、工厂模式
简介：在基类中定义一个返回不同子类对象的接口
要点：
1.在基类中定义一个静态方法，根据传入的值得不同，调用不同子类的构造函数、并返回指向基类的指针
2.将需要子类实现的方法定义为虚方法
3.基类并不会实例化一个对象，而是将对象的实例化延后到子类中进行
4.生成对象时，不显示使用new以及子类构造函数

#include <iostream>
using namespace std;
enum{circle, square, triangle};
class Shape
{
public:
    static Shape* getShape(int);
    virtual void draw()  = 0;//纯虚函数，不必提供定义
    virtual ~Shape() { cout<<"Bye shape"<<endl;}

};

class Circle : public Shape
{
    public:
       void draw() { cout << "circle " << ": draw" << endl; }
       ~Circle()
       {
           cout<<"Bye circle \n";
       }
};
class Square : public Shape
{
    public:
       void draw() { cout << "square " << ": draw" << endl; }
       ~Square()
       {
           cout<<"Bye Square \n";
       }
};
class Triangle : public Shape
{
    public:
       void draw() { cout << "Triangle " << ": draw" << endl; }
       ~Triangle()
       {
           cout<<"Bye Triangle\n ";
       }
};


Shape*  Shape::getShape(int n)
{
    if(n==circle)
        return new Circle;
    else if(n == square)
        return new Square;
    else
        return new Triangle;
}


int main()
{
    Shape* shape[3];
    for(int i = 0 ; i <3 ; i++)
    {
        shape[i]=Shape::getShape(i);
        shape[i]->draw();
        delete shape[i];
    }
    return 0;
}

二、抽象工厂
简介：创建工厂的超级工厂
要点：在基类中抽象出工厂的一般方法，以此派生出不同类型的工厂

#include <iostream>
using namespace  std;

class Shape {
public:
   Shape()              { id_ = total_++; }
   virtual void draw()  = 0;
protected:
   int         id_;
   static int  total_;
};
int Shape::total_ = 0;

class Circle : public Shape { public:
   void draw() { cout << "circle " << id_ << ": draw" << endl; } };
class Square : public Shape { public:
   void draw() { cout << "square " << id_ << ": draw" << endl; } };
class Ellipse : public Shape { public:
   void draw() { cout << "ellipse " << id_ << ": draw" << endl; } };
class Rectangle : public Shape { public:
   void draw() { cout << "rectangle " << id_ << ": draw" << endl; } };

class Factory { public:
   virtual Shape* createCurvedInstance()   = 0;
   virtual Shape* createStraightInstance() = 0;
   static void recycle( Shape* n) { delete  n;}
};
class SimpleShapeFactory : public Factory 
{
    public:
        Shape* createCurvedInstance()   { return new Circle; }
        Shape* createStraightInstance() { return new Square; }

};
class RobustShapeFactory : public Factory
{
    public:
        Shape* createCurvedInstance()   { return new Ellipse; }
        Shape* createStraightInstance() { return new Rectangle; }
};

int main() {
    Factory*  factorySimple = new SimpleShapeFactory;
    Factory*  factoryRobust = new RobustShapeFactory;
    Shape*    shapes[3];
    shapes[0] = factorySimple->createCurvedInstance();
    shapes[1] = factorySimple->createStraightInstance();
    shapes[2] = factoryRobust->createCurvedInstance();
    for (int i=0; i < 3; i++)
    {
          shapes[i]->draw();
          Factory::recycle(shapes[i]);
    }
    delete factorySimple;
    delete factoryRobust;
    
    return 0;
}

三、建造者模式
简介：将复杂对象的构造过程分解为若干的过程，以便相同的构造过程可以构造出不同表现的对象
要点：
1.将复杂对象分解成若干简单对象
2.将对象不同组件的依赖关系、创建步骤用另外一个类来管理

#include <iostream>
#include <string>
using namespace std;

class Product
{
public:
    void MakePartA(const string&name){ partA=name;}
    void MakePartB(const string&name){ partB=name;}
    void MakePartC(const string&name){ partC=name;}
    std::string get()
    {
        return (partA+" "+partB+" "+partC);
    }

private:
    std::string partA;
    std::string partB;
    std::string partC;
};

class Builder
{
public:
    virtual void buildPartA()=0;
    virtual void buildPartB()=0;
    virtual void buildPartC()=0;
    virtual ~Builder(){}
    Product get()
    {
        return product;
    }
protected:
    Product product;
};
class PLAN_X : public Builder
{
public:
    void buildPartA(){ product.MakePartA("A-X"); }
    void buildPartB(){ product.MakePartB("B-X"); }
    void buildPartC(){ product.MakePartC("C-X"); };
};
class PLAN_Y : public Builder
{
public:
    void buildPartA(){ product.MakePartA("A-Y"); }
    void buildPartB(){ product.MakePartB("B-Y"); }
    void buildPartC(){ product.MakePartC("C-Y"); };
};
class Director
{
public:
    Director(): plan(){};
    void setPlan(Builder* anyPlan)
    {
        if(plan)
            delete plan;
        plan=anyPlan;
    }
    void construct()
    {
        plan->buildPartA();
        plan->buildPartB();
        plan->buildPartC();
    }
    Product getProduct()
    {
        return  plan->get();

    }
    ~Director(){ if(plan) delete plan;}
private:
    Builder* plan;
};

int main()
{
    Director director;
    director.setPlan(new PLAN_X);
    director.construct();
    Product productA=director.getProduct();
    cout<<"The product has been built "<<productA.get()<<endl;
    director.setPlan(new PLAN_Y);
    director.construct();
    Product productB=director.getProduct();
    cout<<"The product has been built "<<productB.get()<<endl;
    return 0;

}

四、单例模式
简介：确保某个类只有一个实例，并提供全局指针来访问它
要点：
1.声明一个指向这个类的指针私有静态指针
2.声明一个公有的、静态接口来返回这个指针
3.将所有的构造（构造、赋值、拷贝）函数声明为私有的
4.可以被继承，但必须将父类构造函数访问权限声明为保护类型，并将父类声明为子类的友元

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

class Logger
{
public:
    static Logger* getInstace();
    static void setType(const string&anyType){ type=anyType;}   //参数列表最好设置为const类型， 否则无法接受字面常量
    virtual void show(){ cout<<"My type is "<<type<<endl;}
protected:
    Logger(){};
private:
    static Logger* instance;
    static string type;
};
Logger* Logger::instance=NULL;
string Logger::type="Logger";

class LoggerPlus : public Logger
{
protected:
    friend class Logger;
    LoggerPlus(){};
private:
    static string type;
};
string LoggerPlus::type="LoggerPlus";
Logger* Logger::getInstace()
{
    if(!instance)
        if(type=="LoggerPlus")
            instance=new LoggerPlus();
        else
            instance=new Logger();
    return instance;
}

int main()
{
    Logger::getInstace()->show();
    Logger::setType("LoggerPlus");
    Logger::getInstace()->show();
}

五、适配器模式
简介：将旧类的接口进行转换，以适应新的应用场景
要点：
1.建立一个代理类（adapter）来实现旧类的接口
2.继承旧类，并在子类中使用adapter的方法来替代旧类的接口

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

class TwoPortPlug
{
public:
    virtual void plugin(){ cout<<"Inserted to two holes socket\n";}
};

class Adapter
{
public:
    void three2two() { cout<<" Ajusted three plugs to two plugs\n";}
};

class ThreePortPlug : public TwoPortPlug
{
public:
    ThreePortPlug(): adapter(){}
    void plugin() override { adapter->three2two();}
    ~ThreePortPlug(){ delete adapter;}
private:
    Adapter* adapter;
};

int main()
{
    ThreePortPlug a;
    a.plugin();

}

六、桥接模式
简介：将抽象与实现分离，使二者可以独立变化
要点：
1.抽象与实现表征的是一个类多个维度的变化
2.实现依赖于抽象
e.g.
不同类型的数据库：MySQL、SQLite，它们是数据库的抽象，不同开发商的数据库会有区别；然后操作数据库的GUI应用，这是实现，可能也会有不同的形式

#include <iostream>
#include <string>

using namespace std;
class SQL
{
public:
    virtual void showVersion()=0;
    virtual ~SQL(){ }
};

class MySQL: public SQL
{
public:
    MySQL() : version( "MySQL") { }
    void showVersion(){ cout<<version<<endl;}
private:
    string version;
};

class SQLite: public SQL
{
public:
    SQLite() : version( "SQLite") { }
    void showVersion(){ cout<<version<<endl;}
private:
    string version;
};


class GUI
{
public:
    GUI( SQL *database):db(database){}
    ~GUI(){delete  db;}
    void showDB(){db->showVersion();}

private:
    SQL* db;

};


int main()
{
    GUI* one = new GUI(new MySQL);
    one->showDB();
    GUI* two = new GUI(new SQLite);
    two->showDB();
    delete one;
    delete two;
}

七、组合模式
简介：包含了容器的容器，一个对象里面包含了以树形结构组织的一系列相似的对象
要点：
1.创建容器和被包含的容器的通用接口
2.定义管理子对象的容器
3.定义操作子对象的方法如add、get、remove
e.g.
假设电脑足够强劲，在一台虚拟机里又开了若干台虚拟机

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Machine
{
public:
    Machine( int ID = 0) : id(ID){ }
    virtual ~Machine(){ }
    void powerOn() { cout<<id<<" powered on"<<endl;}
    void powerOff() { cout<<id<<" powered off "<<endl;}
    virtual void add(Machine*) { } ;
    virtual void remove(const int ) { };
private:
    int id;
};

class MainMachine : public Machine
{
public:
    MainMachine(int ID = 0) :Machine(ID) {}
    void add( Machine* child) override
    {
        list.push_back(child);
        child->powerOn();

    }
    Machine* getChillren(int index)
    {
        return list.at(index);
    }
    void remove(const int index) override
    {
        Machine* child=getChillren(index);
        child->powerOff();
        list.erase(list.begin()+index);
        delete child;
    }

private:
    vector<Machine*> list;
};


int main()
{
    MainMachine machine;
    for(int i = 0 ; i <10 ; i++)
        machine.add(new Machine(i));
    machine.remove(5);
    machine.powerOff();
    return 0;
}

八、装饰器模式
简介：动态地给对象添加新的功能
要点：
1.与继承的区别在于，装饰器可以动态地给一个已经实例化的对象添加新功能
2.先将对象打包，再对包装进行装饰
3.包装在继承了对象的实现和接口的基础上，保留了指向对象的指针作为私有成员，并使用这个指针来调用属于对象的方法（不能使用作用域Conponet::的方式）
4.关键在于虚函数和类作用域：
对于被声明为虚函数类型的函数，指向基类的指针将会调用子类版本；下一次修饰，上一次修饰后的加入的修饰内容在wrapper类的中仍然是可见的

#include <iostream>
#include <string>
using namespace std;


class Conponent
{
public:
    virtual void operation()
    {
        cout<<"Conponent implented"<<endl;
    }
    virtual ~Conponent(){ }

};

class Wrapper : public Conponent
{
public:
    Wrapper( Conponent* c):conponent(c){}
     void operation()
    {
        conponent->operation();//不能使用Conponent::operation()
    }
private:
    Conponent* conponent;
};

class DecoratorA : public Wrapper
{
public:
    DecoratorA(Conponent* c): Wrapper(c){}
    void operation()
    {
        Wrapper::operation();
        cout<<"Decorated with A"<<endl;
    }

};
class DecoratorB : public Wrapper
{
public:
    DecoratorB(Conponent* c): Wrapper(c){}
    void operation()
    {
        Wrapper::operation();
        cout<<"Decorated with B"<<endl;
    }

};


int main()
{
    Wrapper* x = new Wrapper(new Conponent);
    DecoratorA* xA = new DecoratorA(x);
    DecoratorB* xAB = new DecoratorB(xA);
    Conponent* xab = xAB;
    xab->operation();
    return 0;
}

九、外观模式
简介：为子系统的一组接口提供一个统一、更易于使用的接口
要点：
1.外观代理了客户向子系统的请求
2.子系统对客户不可见
3.外观对子系统不可见
e.g.
以前的票务系统买张票要打车、排队、缴费、取票，为方便可以直接找人代理

#include <iostream>
#include <string>
using namespace std;

class TicketSystem
{
public:
    void takeBus(){}
    void waitForYourTurn(){}
    void pay(){}
    void getTicket(){cout<<"Ticket got"<<endl;}
};
class HuangNiu
{
public:
    HuangNiu():step(){}
    void call()
    {
        step->takeBus();
        step->waitForYourTurn();
        step->pay();
        step->getTicket();
    }
private:
    TicketSystem* step;
};

int main()
{
    HuangNiu a;
    a.call();
    return 0;

}

十、享元模式
简介：以重用已有对象的方式，来减少创建对象的数量
要点：
1.新对象以工厂模式获得
2.给每个对象分配唯一标识符，如果请求的对象与既有对象的标识符相同，则工厂返回已有对象
e.g.
陪三秒钟记忆的女朋友去购物，管理购物清单，确保购物车没有重复的商品

#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct ShopItem
{
    string name;
    int order;
};

class  ShopItemFactory
{
public:
    ShopItem* getShopItem(const string&item)
    {
        for(auto i : shopList)
            if(item==i->name)
            {
                 cout<<"There is already an " <<item<<endl;
                 return i;
            }
        ShopItem* newItem = new ShopItem{item,int(shopList.size())};
        shopList.push_back(newItem);
        cout<<"New item " <<item<<" added"<<endl;
        return newItem;
    }
    ~ShopItemFactory()
    {
        for(auto i : shopList) delete i;
        shopList.clear();
    }

private:
    vector<ShopItem*> shopList;

};

int main()
{
    ShopItemFactory* factory = new ShopItemFactory;
    factory->getShopItem("car");
    factory->getShopItem("cat");
    factory->getShopItem("car");
    delete factory;
    return 0;
}

十一、代理模式
简介：为对象创建一个新对象，以提供对原对象更灵活的访问
要点：在新对象中存放指向原对象的指针

#include<iostream>
using namespace std;

class RealSubject
{
public:
    virtual void execute(){cout<<"Original excuted"<<endl;}
    virtual ~RealSubject(){}
};

class ProxySubject:public RealSubject
{
public:
    ProxySubject() :ptr(new RealSubject){}
    ~ProxySubject(){delete ptr;}
    void execute() { cout<<"Proxy excuted"<<endl;}
    RealSubject* operator ->()
    {
        return ptr;
    }
private:
    RealSubject* ptr;

};

int main()
{
    ProxySubject a;
    a.execute();
    a->execute();
}

十二、责任链模式
简介：来自发送端的请求会一直沿接收链传递下去，直到请求被接收链上的某个节点处理
要点：
1.在基类中声明一个指向接收链上下一个节点的的指针
2.如果需要传递请求，则调用代理了下一个节点的基类方法
e.g.
某人问你借钱

#include <iostream>
using namespace std;

class Method
{
public:
    Method():method(NULL){}
    virtual void Borrow(int number)
    {
        if(method)
            method->Borrow(number);
        else
            cout<<"I don't know him"<<endl;
    }
    void setMethod(Method* m){method=m;}
private:
    Method* method;
};

class Cash :public Method
{
public:
    void Borrow(int number)
    {
        if(100 > number)
            cout<<"Borrow him "<<number<<" in cash"<<endl;
        else
            Method::Borrow(number);
    }
};

class AliPay :public Method
{
public:
    void Borrow(int number)
    {
        if(1000 > number)
            cout<<"Borrow him "<<number<<" in aliPay"<<endl;
        else
            Method::Borrow(number);
    }
};

int main()
{
    Cash* cash = new Cash;
    AliPay* alipay = new AliPay;
    cash->setMethod(alipay);
    cash->Borrow(20);
    cash->Borrow(200);
    cash->Borrow(2000);

}

十三、命令模式
简介：将每项操作分别打包成一个对象
要点：
1.面向对象编程中执行一个请求无非就是实例化一个类的对象，再通过对象去调用类方法
2.现在声明一个抽象的命令类，在命令类中包含了指向另一个类对象的指针，以及其中的一个类方法
3.每一个请求都对应命令类下的一个实例，通过往命令类的构造函数中传入不同的类及其中的一个类方法，来达到创建不同命令的目的
4.构建另一个类来专门响应不同的请求及相应的命令
把请求看作一件工作，老板会把请求分配给工人去执行，并指定工人去做什么

#include <iostream>
#include <string>
using namespace std;

class Worker
{
public:
    void draw(){cout<<"drawing"<<endl; }
    void write(){cout<<"writing"<<endl; }
    void read(){cout<<"reading"<<endl; }

};

typedef void (Worker::*callback)();

class Command
{
public:
    virtual void execute()=0;

};

class Job : public Command
{
public:
    Job( Worker* a ,callback skill ):icu(a) ,requirement(skill) { }
    void execute(){ (icu->*requirement)();}
private:
    Worker* icu;
    callback requirement ;

};

class Boss
{
public:
    void handJob(Command* cmd){ cmd->execute(); }

};

int main()
{
    Boss Alex;
    Worker* Lily = new Worker;
    Job* job = new Job( Lily,&Worker::draw);
    Alex.handJob(job);
}

十四、解释器模式
简介：给既定的语言，按其语法定义相应的操作并使用解释器来执行其语句
要点：
定义一个接口来解释一定的上下文

#include <iostream>
#include <cstring>
#include <map>
#include <vector>
#include <string>
using namespace std;

class Interpretion
{
public:
    Interpretion( int scale ,const char* bass ):m_scale(scale),m_bass(bass)
    {
        trans.insert(pair<char,int>('0',0));
        trans.insert(pair<char,int>('1',1));
        trans.insert(pair<char,int>('2',2));
        trans.insert(pair<char,int>('3',3));
        trans.insert(pair<char,int>('4',4));
        trans.insert(pair<char,int>('5',5));
        trans.insert(pair<char,int>('6',6));
        trans.insert(pair<char,int>('7',7));
        trans.insert(pair<char,int>('8',8));
        trans.insert(pair<char,int>('9',9));
        trans.insert(pair<char,int>('A',10));
        trans.insert(pair<char,int>('B',11));
        trans.insert(pair<char,int>('C',12));
        trans.insert(pair<char,int>('D',13));
        trans.insert(pair<char,int>('E',14));
        trans.insert(pair<char,int>('F',15));
    }


    int translate(char a)
    {
        return trans.find(a)->second;
    }
    virtual void interpret(char* )=0;
    virtual ~Interpretion(){ }
    int getWeight(int k)
    {
        int weigt=1;
        for(int i = 0 ;i <k - 1 ;i++ )
            weigt*=m_scale;
        return weigt;
    }
    char getExpress(int k)
    {
        return m_bass[k];
    }


private:
    map<char,int> trans;
    int m_scale;
    const char* m_bass;

};

class HexToDec :public Interpretion
{
public:
    HexToDec( ) :Interpretion(16,"")
    {

    }
    void interpret(char* input )
    {
        int size=strlen(input);
        int result=0;
        for(int i = 0 ; i < size; i++ )
        {
            result+=translate(input[i])*getWeight(size-i);
        }
        cout<<"Hex "<<input<<" to oct is "<<result<<endl;
    }


};

class DecToHex :public Interpretion
{
public:
    DecToHex() : Interpretion(10,"0123456789ABCDEF" ) { }
    void interpret(char* input )
    {
        int result = atoi(input);
        int temp=16;
        cout<<"Dec "<< input<<" to Hex is ";
        vector<char> prints;
        while (true)
        {
            if(result<16)
                prints.push_back(getExpress(result));
            else
                prints.push_back(getExpress(result%16));
            if(result /temp==0) break;
            result/=16;

        }
        for(int i = 0 ; i < prints.size(); i ++)
            cout<<prints.at(prints.size() -i -1);


    }


};


class Contex
{
public:
    Contex():input(NULL){ }
    void getInput()
    {
        if(! input)
        {
            delete input;
            input=NULL;
        }
        input = new char[1000];
        memset(input,'\0',1000);
        cin>>input;
    }
    char* getValue() { return input;}

private:
    HexToDec* HtoD;
    DecToHex* DtoH;
    char* input;


};

int main()
{
    Contex* cont = new Contex();
    cout<<"Enter a hex :\n";
    cont->getInput();
    HexToDec* hexTransfer = new HexToDec();
    hexTransfer->interpret(cont->getValue());
    DecToHex* octTransfer = new DecToHex();
    cout<<"Enter a Dec:\n";
    cont->getInput();
    octTransfer->interpret(cont->getValue());

    delete cont;
    delete hexTransfer;
    delete octTransfer;

}

十五、迭代器模式
简介：提供一种在不暴露内部表达形式的情况下，顺序访问数据集合中的元素的方法
要点：
1.在集合类中定义一个创建迭代器的create_iterator()方法，并给予迭代器类特定的访问权限
2.创建一个可以遍历集合类元素的迭代器类
3.客户端使用集合类的对象来创建迭代器类的对象
4.客户端使用按特定的协议、可以获得集合类对象的第一个元素、当前元素、下一个元素、元素总数

#include <iostream>
#include <vector>
using namespace std;

class Literator;
class List
{
public:
    friend class Literator;
    List(int size ) :m_size(size) ,index(0) {  list=new int[ m_size]{0}; }
    ~List(){ delete list;}
    int currentItem() { return list[index]; }
    Literator* createLiterator();
private:
    int* list;
    int m_size;
    int index;
};

class Literator
{
public:
    Literator(List* object):myList(object) { }
    void first() { myList->index=0;}
    int current() { return myList->currentItem();}
    void next() { myList->index++;}
    bool isDone(){ return myList->index < myList->m_size; }
    ~Literator() { cout<<"Bye~"; }
private:
    List* myList;
};

Literator* List::createLiterator()
{
    return  new  Literator (this);
}

int main(void)
{
    List* test = new List(5);
    Literator* literator= test->createLiterator();
    for(literator->first(); literator->isDone(); literator->next())
        cout<<literator->current();
    delete test;
    delete literator;
    return 0;
}

十六、中介模式
简介：定义一个来管理复数对象的交互，使对象之间不需要显示调用彼此
要点：
1.抽象一个新的类来管理对象之间的交互
2.对象都仅与这个新的类的实例进行交互

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Customer
{
public:
    Customer(const string& name) :m_name(name) { }
    void speak(const string&word){ cout<<m_name<<" said "<<word<<endl; }
    void listen(const string&word) { cout<<m_name<<" heard "<<word <<endl;}
private:
    string m_name;

};

class Mediator
{
public:
    ~Mediator()
    {
        for ( auto i : namelist)
            delete i;
    }
    void send(int id, const string&msg)
    {
        if( id < namelist.size())
        {
            namelist[id]->speak(msg);
            for(int i = 0 ; i <namelist.size(); i++)
                if(id != i)
                    namelist[i]->listen(msg);
        }
    }
    void add( Customer* cus){ namelist.push_back(cus); }

private:
    vector<Customer*> namelist;
};

int main()
{
    Mediator* mediator = new Mediator;
    Customer* A = new Customer("Alex");
    Customer* B = new Customer("Alice");
    Customer* C = new Customer("Mike");
    mediator->add(A);
    mediator->add(B);
    mediator->add(C);
    mediator->send(0,"Hello");

}

十七、备忘录模式
简介：在不破坏封装性的前提下，保存对象的状态，以便撤销操作或回滚至原状态
要点：
1.区分并创建原件和管理员类
2.创建一个备份类，将原件声明为友元
3.由原件创建备份，并在备份中保存自己的状态
4.由管理员确定何时保存、回滚原件状态
5.从备份从恢复原件的状态

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Memento
{
public:
    friend class Original;
    Memento ( int s ) :memState(s){ }
    int  getState(){return memState;}
private:
    int memState;

};


class Original
{
public:
    Original(int state=0) : m_state(state) { }
    void setState(int s){ m_state = s;}
    void restore( Memento* m ) { m_state = m->getState();}
    void getState() { cout<<"Current state is "<<m_state<<endl;}
    Memento* CreateMemento() { return new Memento(m_state);  }

private:
    int m_state;
    
};

class CareTaker
{
public:
    CareTaker( Original* const o) :orignal(o) { }
    ~CareTaker(){ for(auto i : history) delete i; }
    void save() { history.push_back(orignal->CreateMemento()); }
    void undo()
    {
        if(! history.empty())
        {
            Memento* m = history.back();
            orignal->setState(m->getState());
            history.pop_back();
            delete m;
        }
    }

private:
    Original* orignal;
    vector<Memento*> history;
};

int main()
{
    Original* originator = new Original;
    CareTaker* takecare = new CareTaker (originator);
    originator->setState(100);
    takecare->save();
    originator->getState();
    originator->setState(50);
    takecare->save();
    originator->getState();
    originator->setState(5);
    takecare->undo();
    originator->getState();


}

十八、观察者模式
简介：观察者建立了一对多的依赖关系，在一个对象的状态发生改变时，其它对象也自动更新状态
要点：
1.将不变或者不存在依赖关系的部分抽象成主体
2.将可变或存在依赖关系的部分抽象成观察者
3.主体仅仅与观察者耦合
4…用户决定观察者的数量和类型
5.将观察者注册至主体
6.主体状态发生改变的同时，将事件广播至所有注册了的观察者

e.g.火警报警器响起时，打开灭火器、播放广播、疏散人流

#include <iostream>
#include <vector>
using namespace std;

class AlarmListener
{
public:
    virtual ~AlarmListener(){ }
    virtual void takeAction()=0;
};

class FireFigter : public AlarmListener
{
 public:
    void takeAction() { cout<<"Firefigher coming "<<endl;}
};

class Radio : public AlarmListener
{
public:
    void takeAction() { cout<<"Broading message "<<endl;}
};

class Alarm
{
public:
    ~Alarm() { for(auto i : list) delete i;}
    void fireDetected( ){ for(auto i : list) i->takeAction(); }
    void attach(AlarmListener* m) { list.push_back(m); }
private:
    vector<AlarmListener*> list;

};

int main()
{
    Alarm* alarm =  new Alarm;
    alarm->attach(new FireFigter);
    alarm->attach(new Radio);
    alarm->fireDetected();
}

十九、状态模式
简介：允许对象在不同状态下，表现出不同的行为
要点：
1.创建一个所有状态的基类，并尽可能定义更多默认的行为
2.为每个状态创建一个子类，并重写基类方法
3.新建一个包含了基类的类，并提供修改具体使用哪个子类的方法

#include <iostream>
#include <vector>
using namespace std;


class State
{
public:
    virtual void handRequest()=0;
    virtual ~State() { }

};

class StateA :public State
{
public:
    void handRequest() { cout<<"State A "<<endl; }
};

class StateB :public State
{
public:
    void handRequest() { cout<<"State B "<<endl; }
};


class Machine
{

public:
    Machine():currentState(NULL) {}
    ~Machine(){ if(currentState) delete currentState;}
    void setState(State* s)
    {
        if(currentState)
            delete currentState;
            currentState=s;

    }
    void request(){ if(currentState) currentState->handRequest();}

private:
    State* currentState;
};

int main()
{
    Machine* machine = new Machine;
    machine->request();
    machine->setState(new StateA);
    machine->request();
    machine->setState(new StateB);
    machine->request();

}

二十、策略模式
简介：和上面的状态模式的区别就是，不需要提供改变当前状态的接口
要点：
1.用户可以决定使用哪个算法
2.不同算法使用相同的接口

#include <iostream>
#include <vector>
using namespace std;


class Strategy
{
public:
    virtual void handwork()=0;
    virtual ~Strategy() { }

};

class StrategyA :public Strategy
{
public:
    void handwork() { cout<<"Strategy A "<<endl; }
};

class StrategyB :public Strategy
{
public:
    void handwork() { cout<<"Strategy B "<<endl; }
};


class Machine
{

public:
    Machine( Strategy* s):currentStrategy(s) {}
    ~Machine(){  delete currentStrategy;}
    void work(){  currentStrategy->handwork();}

private:
    Strategy* currentStrategy;
};

int main()
{

    Machine* machine = new Machine(new StrategyA);
    machine->work();

}

二十一、模板模式
简介：在基类中定义算法的框架，子类重写基类方法来实现具体的、有差异的步骤
要点：
1.在基类中实现标准的部分
2.子类来实现差异的部分

#include <iostream>
#include <vector>
using namespace std;

class Operation
{
public:
    virtual ~Operation() { }
    void start() { cout<<"Starting ..."<<endl;}
    virtual void stepA()=0;
    virtual void stepB()=0;
    void end() { cout<<"Ended..\n";}
    void execute()
    {
        start();
        stepA();
        stepB();
        end();
    }
};

class OperationOne : public Operation
{
public:
    void stepA() override{ cout<<"One's A"<<endl;}
    void stepB() override{ cout<<"One's B"<<endl;}

};

class OperationTwo : public Operation
{
public:
    void stepA() override{ cout<<"Two's A"<<endl;}
    void stepB() override{ cout<<"Two's B"<<endl;}

};

 int main(int argc, char *argv[])
{
    OperationOne one;
    OperationTwo two;
    one.execute();
    two.execute();
    return 0;
}

来份西红柿炒番茄

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
23种设计模式的C++实现、简介、要点

一、工厂模式简介：在基类中定义一个返回不同子类对象的接口要点：1.在基类中定义一个静态方法，根据传入的值得不同，调用不同子类的构造函数、并返回指向基类的指针2.将需要子类实现的方法定义为虚方法3.基类并不会实例化一个对象，而是将对象的实例化延后到子类中进行4.生成对象时，不显示使用new以及子类构造函数#include <iostream>using namespace std;enum{circle, square, triangle};class Shape{publ
复制链接

扫一扫

专栏目录