设计模式总结

最新推荐文章于 2023-03-11 22:19:15 发布
最新推荐文章于 2023-03-11 22:19:15 发布
阅读量1.1k 收藏 1
点赞数
文章标签： 设计模式 c++ 开发语言 ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011616934/article/details/126588980
版权

一、创建型模式

1.单例模式

只能够创建一个类对象

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

class Singleton{
    public:
        static Singleton* instance() {
            if (_instance == nullptr) {
                _mtx.lock();
                 this_thread::sleep_for(chrono::milliseconds(10));
                 if (_instance == nullptr) _instance = new Singleton();
                _mtx.unlock();
            }
            return _instance;
        }
    private:
        Singleton() {}
        ~Singleton() {}
        static Singleton* _instance;
        static mutex _mtx;
};

Singleton* Singleton::_instance = nullptr;
mutex Singleton::_mtx;

void getInstance() {
    cout << Singleton::instance() << endl;
}

int main() {
    thread t1(&getInstance);
    thread t2(&getInstance);
    thread t3(&getInstance);
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

2.工厂模式

通过一个工厂建造不同产品

#include <iostream>
using namespace std;

class AbstractCar{
public:
    virtual void printName() = 0;
};

class BMW : public AbstractCar {
public:
    void printName() override {
        cout << "name = BMW\n";
    }
};

class BENZ : public AbstractCar {
public:
    void printName() override {
        cout << "name = BENZ\n";
    }
};

class Factory {
public:
    AbstractCar* getCar(std::string name) {
        if (name == "BMW") {
            return new BMW();
        } else if (name == "BENZ") {
            return new BENZ();
        } else {
            return nullptr;
        }      
    }
};

int main() {
    Factory factory;
    AbstractCar* arr[5];
    arr[0] = factory.getCar("BMW");
    arr[1] = factory.getCar("BENZ");
    arr[2] = factory.getCar("AUDI");
    arr[3] = factory.getCar("TOYOTA");
    arr[4] = factory.getCar("BENZ");
    for (auto it : arr) {
        if (it)
            it->printName();
        else
            cout << "object is nullptr" << endl;
    }
    return 0;
}

3.建造者模式

通过不同建造器来创建不同产品

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

class AbstractCar {
protected:
    int wheel;
    int engine;
    int color;
public:
    virtual void printName() = 0;
    virtual void debug() = 0;
};

class  BMW : public AbstractCar {
public:
    void printName() override {
        cout << "name = BMW\n";
    }
    void debug() override {
        cout << "name = BMW wheel = " << wheel << " engine = " << engine  << " color = " << color << endl;
    }
};

class  BENZ : public AbstractCar {
public:
    void printName() override {
        cout << "name = BENZ\n";
    }
    void debug() override {
        cout << "name = BENZ wheel = " << wheel << " engine = " << engine  << " color = " << color << endl;
    }
};

class AbstractBuilder{
public:
    virtual void buildA(AbstractCar* car) = 0;
    virtual void buildB(AbstractCar* car) = 0;
    virtual void buildC(AbstractCar* car) = 0;
    virtual AbstractCar* getCar() = 0;
};

class BMWBuilder : public AbstractBuilder {
public:
    void buildA(AbstractCar* car) override {
        cout << car << " BMW buildA \n";
    }
    void buildB(AbstractCar* car) override {
        cout << car << " BMW buildB \n";
    }
    void buildC(AbstractCar* car) override {
        cout << car << " BMW buildC \n";
    }
    AbstractCar* getCar() override {
        AbstractCar* car = new BMW();
        buildA(car);
        buildB(car);
        buildC(car);
        return car;
    }
};

class BENZBuilder : public AbstractBuilder {
public:
    void buildA(AbstractCar* car) override {
        cout << car << " BENZ buildA \n";
    }
    void buildB(AbstractCar* car) override {
        cout << car << " BENZ buildB \n";
    }
    void buildC(AbstractCar* car) override {
        cout << car << " BENZ buildC \n";
    }
    AbstractCar* getCar() override {
        AbstractCar* car = new BENZ();
        buildC(car);
        buildA(car);
        buildB(car);
        return car;
    }
};

class Factory {
private:
    AbstractBuilder* _builder;
public:
    void setBuilder(AbstractBuilder* builder) {
        _builder = builder;
    }
    AbstractCar* buildCar() {
        if (_builder)
            return _builder->getCar();
        return nullptr;
    }
};

int main() {
    Factory factory;
    BMWBuilder* builder1 = new BMWBuilder();
    BENZBuilder* builder2 = new BENZBuilder();
    factory.setBuilder(builder1);
    auto car1 = factory.buildCar();
    car1->debug();
    delete car1;

    factory.setBuilder(builder2);
    auto car2 = factory.buildCar();
    car2->debug();
    delete car2;

    delete builder1;
    delete builder2;
    return 0;
}

 

4.原型模式

通过自身来复制一个对象

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

class AbstractProto {
public:
    virtual AbstractProto* clone() = 0;
    virtual void print() = 0;
};

class ProtoTypeA: public AbstractProto {
public:
    AbstractProto* clone() override {
        return new ProtoTypeA(*this);
    }
    void print() override {
        cout << "ProtoTypeA --- print\n";
    }
};

class ProtoTypeAA: public ProtoTypeA {
public:
    AbstractProto* clone() override {
        return new ProtoTypeAA(*this);
    }
    void print() override {
        cout << "ProtoTypeAA --- print\n";
    }
};

// AbstractProto* clone(AbstractProto* obj) {
//     auto p1 = dynamic_cast<ProtoTypeA*>(obj);
//     auto p2 = dynamic_cast<ProtoTypeAA*>(obj);
//     if (p1) {
//         return new ProtoTypeA(obj);     //不可行
//     }
// }

int main() {
    AbstractProto* p1 = new ProtoTypeA();
    AbstractProto* p2 = new ProtoTypeAA();
    auto p3 = p1->clone();
    auto p4 = p2->clone();

    p3->print();
    p4->print();

    delete p4;
    delete p3;
    delete p2;
    delete p1;
    return 0;
}

二、 结构型模式

1.桥接模式

使用委托方式将抽象和实现彻底地解耦，好处是抽象和实现可分别独立变化，系统耦合性得到很好降低。

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

class ISoft {
public:
    virtual void run() = 0;
};

class IPhone {
public:
    IPhone() : _soft(nullptr) {}
    virtual void runSoft() = 0;
    void installSoft(ISoft* soft) {
        _soft = soft;
    }
protected:
    ISoft* _soft;
};

class PhoneA : public IPhone {
public:
    void runSoft() override {
        if (_soft) {
            cout << "PhoneA start launch soft\n";
            _soft->run();
        } else {
            cout << "PhoneA start launch soft is null\n";
        }
    }
};

class PhoneB : public IPhone {
public:
    void runSoft() override {
        if (_soft) {
            cout << "PhoneB start launch soft\n";
            _soft->run();
        } else {
            cout << "PhoneB start launch soft is null\n";
        }
    }
};

class SoftA : public ISoft {
public:
    void run() override {
        cout << "Soft A IS RUNNING \n";
    }
};

class SoftB : public ISoft {
public:
    void run() override {
        cout << "Soft B IS RUNNING \n";
    }
};

int main() {
    ISoft* pSoft1 = new SoftA();
    ISoft* pSoft2 = new SoftB();
    IPhone* p1 = new PhoneA();
    IPhone* p2 = new PhoneB();

    p1->installSoft(pSoft2);
    p2->installSoft(pSoft1);
    p1->runSoft();
    p2->runSoft();

    delete p2;
    delete p1;
    delete pSoft2;
    delete pSoft1;
    return 0;
}

 2.适配器模式

将一个类的接口转换成客户希望的另一个接口。该模式使原本由于接口不兼容而不能一起工作的那些类可一起工作。

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

class Target {
public:
    virtual int request() = 0;
};

class Adaptee {
public:
    virtual int specialRequest() {
        cout << "Adaptee Special Request\n";
        return 66;
    }
};

class Adapter : public Target, public Adaptee {
public:
    int request() override {
        return this->specialRequest();
    }
};

class AAdapter : public Target {
private:
    Adaptee* _adaptee;
public:
    AAdapter() = delete;
    AAdapter(Adaptee* p) : _adaptee(p) {}
    int request() override {
        return _adaptee->specialRequest();
    }
};

//外部接口需求
void interfaceRequest(Target* target) {
    auto ret = target->request();
    cout << "ret = " << ret << endl;
}

int main() {
    Adapter* adapter = new Adapter();
    interfaceRequest(adapter);
    delete adapter;

    Adaptee* adaptee = new Adaptee();
    AAdapter* aadapter = new AAdapter(adaptee);
    interfaceRequest(aadapter);
    delete aadapter;
    delete adaptee;

    return 0;
}

3.装饰器者模式

装饰者提供一种给类增加职责的方法，非通过继承实现，通过组合。

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

class AbstractPerson {
public:
    virtual void run() = 0;
    virtual void walk() = 0;
};

class Person : public AbstractPerson {
public:
    void run() override {
        cout << "Person run \n";
    }
    void walk() override {
        cout << "Person walk \n";
    }
};

class AbstractDecorator : public AbstractPerson {
protected:
    AbstractPerson* _person;
public:
    AbstractDecorator(AbstractPerson* p) : _person(p) {}
    virtual ~AbstractDecorator() {}

    void run() override {
        cout << "AbstractDecorator Person run \n";
        _person->run();
    }
    void walk() override {
        cout << "AbstractDecorator Person walk \n";
        _person->walk();
    }
};

class PersonBlack : public AbstractDecorator {
public:
    using AbstractDecorator::AbstractDecorator;
    void run() override {
        cout << "Black Person run fast\n";
        _person->run();
        _person->run();
    }
    void walk() override {
        cout << "Black Person walk fast\n";
        _person->walk();
        _person->walk();
    }
};

class PersonOld : public AbstractDecorator {
public:
    using AbstractDecorator::AbstractDecorator;
    void run() override {
        cout << "Old Person cannot run\n";
    }
    void walk() override {
        cout << "Old Person walk slowly\n";
        _person->walk();
    }
};

//外部可调用接口，无法做修改
void executeRun(AbstractPerson* p) {
    p->run();
}

void executeWalk(AbstractPerson* p) {
    p->walk();
}

int main() {
    AbstractPerson* p = new Person();
    executeRun(p);
    executeWalk(p);

    PersonBlack* p1 = new PersonBlack(p);
    PersonOld* p2 = new PersonOld(p);
    cout << "---------------decorator black---------------\n";
    executeRun(p1);
    executeWalk(p1);
    cout << "---------------decorator old---------------\n";
    executeRun(p2);
    executeWalk(p2);

    delete p2;
    delete p1;
    delete p;
    return 0;
}

 

4.外观模式

为子系统中一组接口提供一个一致接口，使子系统更加容易使用。

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

class ISystem {
public:
    virtual bool Register() = 0;
    virtual bool Login() = 0;
};

class SystemA: public ISystem {
public:
    bool Register() override {
        cout << "SystemA register\n";
        return true;
    }
    bool Login() override {
        cout << "SystemA login\n";
        return true;
    }
};

class SystemB: public ISystem {
public:
    bool Register() override {
        cout << "SystemB register\n";
        return true;
    }
    bool Login() override {
        cout << "SystemB login\n";
        return true;
    }
};

class SystemC: public ISystem {
public:
    bool Register() override {
        cout << "SystemC register\n";
        return true;
    }
    bool Login() override {
        cout << "SystemC login\n";
        return true;
    }
};

class Facade : public ISystem {
protected:
    vector<ISystem*> _systems;

public:
    bool Register() override {
        for (auto p: _systems) {
            p->Register();
        }
        return true;
    }
    bool Login() override {
        for (auto p: _systems) {
            p->Login();
        }
        return true;
    }
    void addSystem(ISystem* system) {
        _systems.push_back(system);
    }
};

int main() {
    Facade facade;
    ISystem* sys1 = new SystemA();
    ISystem* sys2 = new SystemB();
    ISystem* sys3 = new SystemC();
    facade.addSystem(sys1);
    facade.addSystem(sys2);
    facade.addSystem(sys3);

    facade.Register();
    facade.Login();

    delete sys1;
    delete sys2;
    delete sys3;
    return 0;
}

 

5.代理模式/委托模式

作用是找一个代理对象来替我们访问某个对象。

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

class Person{
public:
    Person() : _proxy(nullptr) {}
    virtual ~Person() {}

    virtual void rentHouse() = 0;
    virtual void setProxy(Person* p) {_proxy = p;}

protected:
    Person* _proxy;
};

class Proxy : public Person {
public:
    using Person::Person;
    void rentHouse() override {
        if (!_proxy) return;
        cout << "Proxy help to rent house\n";
        _proxy->rentHouse();
        cout << "Proxy need to charge fee as intermediary\n";
    }
};

class Master: public Person {
public:
    void rentHouse() override {
        cout << "Master need rent house\n";
    }
};

int main() {
    Person* p = new Master();
    Person* proxy = new Proxy();
    proxy->setProxy(p);
    proxy->rentHouse();

    delete p;
    delete proxy;
    return 0;
}

 6.享元模式

主要用于减少创建对象的数量，以减少内存占用和提供性能。这种类型的设计模式数据结构型模式，提供减少对象竖向从而改善应用所需的对象结构方式。

7.组合模式

用于把一组相似对象当做一个单一对象。依据树形结构来组合对象，用来表示部分以及整体层次。属于结构型模式，创建了对象组的树形结构。

三、行为型模式

1.模板方法模式

将逻辑算法放在抽象基类中，并定义好需要实现细节的接口，子类中实现细节。

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

class Factory{
public:
    virtual void templateMethod() {
        this->buildA();
        this->buildB();
        this->buildC();
        this->buildD();
    }

    virtual void buildA() = 0;
    virtual void buildB() = 0;
    virtual void buildC() = 0;
    virtual void buildD() = 0;
};

class FactoryBMW: public Factory {
public:
    void buildA() override {
        cout << "BuildA in BMW Factory\n";
    }
    void buildB() override {
        cout << "buildB in BMW Factory\n";
    }
    void buildC() override {
        cout << "buildC in BMW Factory\n";
    }
    void buildD() override {
        cout << "buildD in BMW Factory\n";
    }
};

class FactoryBENZ: public Factory {
public:
    void buildA() override {
        cout << "BuildA in BENZ Factory\n";
    }
    void buildB() override {
        cout << "buildB in BENZ Factory\n";
    }
    void buildC() override {
        cout << "buildC in BENZ Factory\n";
    }
    void buildD() override {
        cout << "buildD in BENZ Factory\n";
    }
};

int main() {
    Factory* p1 = new FactoryBMW();
    Factory* p2 = new FactoryBENZ();
    p1->templateMethod();
    p2->templateMethod();

    delete p1;
    delete p2;
    return 0;
}

2.策略模式

策略模式同模板模式，都是未了给业务逻辑具体实现和抽象接口之间的解耦。策略模式将逻辑算法封装到一个类里面，通过组合方式将具体算法实现在组合对象中实现，再通过委托方式将抽象接口的实现委托组合对象实现。

#include <iostream>
using namespace std;

class Strategy{
public:
    virtual void sort(int arr[], int n) = 0;
};

class Context {
public:
    void setData(int* data, int size) {
        _arr = data;
        _size = size;
    }
    void setStrategy(Strategy* p) {
        _strategy = p;
    }
    void sort() {
        if (_strategy && _arr)
            _strategy->sort(_arr, _size);
    }
    void print() {
        for (int i = 0; i < _size; ++i) {
            cout << _arr[i] << " ";
        }
        cout << endl;
    }

private:
    int* _arr;
    int _size;
    Strategy* _strategy;
};

class BubbleSort : public Strategy {
public:
    void sort(int arr[], int size) override {
        cout << "Bubble sort\n";
        if (size <= 1) return;
        for (int i = 1; i < size; i++) {
            for (int j = i -1; j >= 0; j--) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                else {
                    break;
                }
            }
        }
    }
};

class InsertSort : public Strategy {
public:
    void sort(int a[], int n) override {
        cout << "Insert Sort\n";
        if (n <= 1) return;
        for (int i = 0; i < n - 1; i++) {
            int minID = i;
            for (int j = i + 1; j < n; j++) {
                if (a[j] < a[minID]) {
                    minID = j;
                }
            }
            int temp = a[i];
            a[i] = a[minID];
            a[minID] = temp;
        }
    }
};

class SelectSort : public Strategy {
public:
    void sort(int a[], int n) override {
        cout << "Select Sort \n";
        if (n <= 1) return;
        for (int i = 0; i < n - 1; i++) {
            int minID = i;
            for (int j = i + 1; j < n; j++) {
                if (a[j] < a[minID]) {
                    minID = j;
                }
            }
            int temp = a[i];
            a[i] = a[minID];
            a[minID] = temp;
        }
    }
};

int main() {
    Context* ctx = new Context();
    int arr[] = {23, 34, 1,24 ,34,434,343,2, 2,4 ,5 ,5,242, 3, 5, 2,87,89};
    ctx->setData(arr, sizeof(arr)/sizeof(int));
    Strategy* p1 = new BubbleSort();
    Strategy* p2 = new InsertSort();
    Strategy* p3 = new SelectSort();

    ctx->setStrategy(p2);
    ctx->sort();
    ctx->print();

    delete p1;
    delete p2;
    delete p3;
    delete ctx;
    return 0;
}

 3.观察者模式

解决问题为：建立一个subject对多个observer的依赖关系，并且做到当一变化时，依赖这个一的多也能够同步变化。

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

class Subject;
class AbstractObserver{
public:
    AbstractObserver(string name) : _name(name) {}
    virtual void update(Subject* p) = 0;
    inline string getName() {return _name;}
protected:
    string _name;
};

class ObserverA :  public AbstractObserver{
public:
    using AbstractObserver::AbstractObserver;
    void update(Subject* p) override {
        cout << "Update ObserverA name = " << _name << " this =  " << this << endl;
    }
};

class ObserverB :  public AbstractObserver{
public:
    using AbstractObserver::AbstractObserver;
    void update(Subject* p) override {
        cout << "Update ObserverB name = " << _name << " this =  " << this << endl;
    }
};

class Subject{
public:
    void addObserver(AbstractObserver* p) {
        auto arr = _observers.find(p->getName());
        if (arr == _observers.end()) {
            vector<AbstractObserver*> vec;
            vec.push_back(p);
            _observers[p->getName()] = vec;
        } else {
            _observers[p->getName()].push_back(p);
        }
        //_observers[p->getName()] = p;
    }
    void notify(string s) {
        if (_observers.find(s) != _observers.end()) {
            for (auto p: _observers[s])
                p->update(this);
        } else {
            cout << "not found and observers\n" << endl;
            // for (auto p : _observers) {
            //     p.second->update(this);
            // }
        }
    }
protected:
    map<string, vector<AbstractObserver*>> _observers;
};

int main() {
    Subject Subject;
    AbstractObserver* p1 = new ObserverA("abc");
    AbstractObserver* p2 = new ObserverA("abdfsdss");
    AbstractObserver* p3 = new ObserverA("23rf");
    AbstractObserver* p4 = new ObserverA("abc");    
    AbstractObserver* p5 = new ObserverA("fsf");
    AbstractObserver* p6 = new ObserverA("vxcv3");

    Subject.addObserver(p1);
    Subject.addObserver(p2);
    Subject.addObserver(p3);
    Subject.addObserver(p4);
    Subject.addObserver(p5);
    Subject.addObserver(p6);

    Subject.notify("abc");

    delete p1;
    delete p2;
    delete p3;
    delete p4;
    delete p5;
    delete p6;
    return 0;
}

 4.命令模式

通过将请求封装到一个对象中，并将请求的接受者存档到具体的ConcreteCommand类中Receiver中，从而实现调用操作的对象和操作的具体实现者之间的解耦。

#include <iostream>
using namespace std;

class Receiver {
public:
    virtual void action() {
        cout << "Execute command\n";
    }
};

class ReceiverA : public Receiver {
public:
    virtual void action() {
        cout << "Execute command A\n";
    }
};

class Command {
public:
    Command(Receiver* p) : _receiver(p) {}
    virtual void setReceiver(Receiver* p) {_receiver = p;}
    virtual void doCommand(int n) = 0;
protected:
    Receiver* _receiver;
};

class CommandA : public Command {
public:
    using Command::Command;
    CommandA(Receiver* p, Receiver* p2) : Command(p), _receiver2(p2) {

    }
    void setReceiver2(Receiver* p) {_receiver2 = p;}
    void doCommand(int n) override {
        if (n == 0)
            _receiver->action();
        else
            _receiver2->action();
    }
protected:
    Receiver* _receiver2;
};

class CommandB : public Command {
public:
    void doCommand(int n) override {
        cout << "CommandB doCommand\n";
        _receiver->action();
    }
};

class Invoker {
public:
    Invoker() : _command(nullptr) {}
    void setCommand(Command* p) {
        _command = p;
    }
    void executeCommand(int n = 0) {
        if (_command) _command->doCommand(n);
    }
protected:
    Command* _command;
};

int main() {
    Invoker* invoker = new Invoker();
    Receiver* recv = new Receiver();
    ReceiverA* recvA = new ReceiverA();
    Command* command = new CommandA(recv, recvA);

    invoker->setCommand(command);
    invoker->executeCommand();
    invoker->executeCommand(1);

    delete command;
    delete recvA;
    delete recv;
    delete invoker;
    return 0;
}

 5.访问者模式

不改变类的前提下定义作用于这些元素的新操作。

#include <iostream>
using namespace std;

class Node;
class Visitor {
public:
    virtual void visit(Node* node) = 0;
};

class Node{
public:
    virtual void accept(Visitor* visitor) = 0;
};

class NodeA : public Node {
    friend class VisitorA;
public:
    NodeA() {
        s = "hello tra";
    }
    void accept(Visitor* visitor) override {
        visitor->visit(this);
    }
protected:
    string s;
};

class NodeB : public Node {
    friend class VisitorB;
public:
    NodeB() {
        s = "hello taffee";
    }
    void accept(Visitor* visitor) override {
        visitor->visit(this);
    }
protected:
    string s;
};

class VisitorA : public Visitor {
public:
    void visit(Node* node) override {
        NodeA* p = dynamic_cast<NodeA*>(node);
        if (p) {
            cout << "Node A ---" << p->s.c_str() << endl;
        }
    }
};

class VisitorB : public Visitor {
public:
    void visit(Node* node) override {
        NodeB* p = dynamic_cast<NodeB*>(node);
        if (p) {
            cout << "Node B ---" << p->s.c_str() << endl;
        }
    }
};

int main() {
    Node* p1 = new NodeA();
    Node* p2 = new NodeB();
    VisitorA* p3 = new VisitorA();
    VisitorB* p4 = new VisitorB();
    p1->accept(p3);
    p2->accept(p4);

    delete p4;
    delete p3;
    delete p2;
    delete p1;

    return 0;
}

 6.责任链模式

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

#include <iostream>
using namespace std;

struct Request{
    int days;
    int type;
    string desc;
};

class Handler{
public:
    Handler() : _nextHandler(nullptr) {}
    virtual void setNextHandler(Handler* p) {_nextHandler = p;}
    virtual void dealRequest(Request* p) = 0;
    virtual void postRequest(int day, int type, string desc) {
        Request* p = new Request{day, type, desc};
        this->dealRequest(p);
        delete p;
    }
protected:
    Handler* _nextHandler;
};

class Employee : public Handler {
public:
    void dealRequest(Request* p) override {
        cout << "没有权限，需要上级审核\n";
        if (this->_nextHandler) {
            this->_nextHandler->dealRequest(p);
        }
    }
};

class TeamLeader : public Handler {
public:
    void dealRequest(Request* p) override {
        if (p->days <= 3)
            cout << "小于3天，直接通过审核\n";
        else if (this->_nextHandler) {
            cout << "没有权限，需要上级审核\n";
            this->_nextHandler->dealRequest(p);
        }
    }
};

class Manager : public Handler {
public:
    void dealRequest(Request* p) override {
        if (p->days <= 7)
            cout << "小于7天，直接通过审核\n";
        else if (this->_nextHandler) {
            cout << "没有权限，需要上级审核\n";
            this->_nextHandler->dealRequest(p);
        }
    }
};

class Boss : public Handler {
public:
    void dealRequest(Request* p) override {
        if (p->days <= 15)
            cout << "小于15天，直接通过审核\n";
        else if (this->_nextHandler) {
            cout << "没有权限，需要上级审核\n";
            this->_nextHandler->dealRequest(p);
        }
        else {
            cout << "大于15天，拒绝\n";
        }
    }
};

int main() {
    Handler* p1 = new Boss();
    Handler* p2 = new Manager();
    Handler* p3 = new TeamLeader();
    Handler* p4 = new Employee();
    p1->setNextHandler(nullptr);
    p2->setNextHandler(p1);
    p3->setNextHandler(p2);
    p4->setNextHandler(p3);

    //p4->postRequest(2, 0, "事假");
    //p4->postRequest(6, 1, "病假");
    p4->postRequest(15, 2, "婚假");
    delete p1;
    delete p2;
    delete p3;
    delete p4;
    return 0;
}

 7.迭代器模式

提供一种顺序访问一个聚合对象中各个元素，而不暴露该对象的内部表示。

8.备忘录模式

保存一个对象的某个状态，以便在适当的时候恢复对象。属于行为型模式。

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

struct StateInfo
{
    int a, b;
};


class CareTaker{
public:
    static CareTaker* _instance;
    static CareTaker* instance() {
        if (_instance == nullptr) {
            _instance = new CareTaker();
        }
        return _instance;
    }
    virtual ~CareTaker() {
        for (auto it : _states) {
            delete it;
        }
    }
    void addState(int a, int b) {
        _states.push_back(new StateInfo{a, b});
    }
    StateInfo* getState(int index) {
        if (_states.size() > index) {
            return _states[index];
        }
        return nullptr;
    }
protected:
    vector<StateInfo*> _states;
};

class Originator{
public:
    Originator() : _a(0), _b(0) {}
    void SetA(int a) {
        _a = a;
        this->saveState();
    }
    void SetB(int b) {
        _b = b;
        this->saveState();
    }
    void saveState() {
        CareTaker::instance()->addState(_a, _b);
    }
    void recoverState(int index) {
        auto p = CareTaker::instance()->getState(index);
        if (p) {
            _a = p->a;
            _b = p->b;
        }
        cout << "a = " << _a << " b = " << _b << endl;
    }

private:
    int _a, _b;
};

CareTaker* CareTaker::_instance = nullptr;
int main() {
    Originator* p = new Originator();
    p->SetA(1);
    p->SetA(2);
    p->SetB(4);
    p->SetA(324);
    p->SetB(23);
    p->SetA(3);

    //index 从0开始的
    cout << "-------------恢复第1步-------------" << endl;
    p->recoverState(1);

    cout << "-------------恢复第5步-------------" << endl;
    p->recoverState(5);

    cout << "-------------恢复第15步-------------" << endl;
    p->recoverState(15);
    return 0;
}

 9.中介者模式

用来降低多个对象和类之间的通信复杂性。提供一个中介类，该类通常处理不同类之间的通信，并直接松耦合，使代码易于维护。

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

class Colleague;
class Mediator{
public:
    virtual void deal(Colleague* p) = 0;
    virtual void setColleague(Colleague* from, Colleague* to) {
        _from = from;
        _to = to;
    }

protected:
    Colleague* _from;
    Colleague* _to;
};

class Colleague {
public:
    Colleague(Mediator* p) : _mediator(p) {}
    virtual void send() = 0;
    virtual void receive(string s) = 0;
protected:
    Mediator* _mediator;
};

class ColleagueA : public Colleague {
public:
    using Colleague::Colleague;
    void send() override {
        _mediator->deal(this);
    }
    void receive(string s) override {
        cout << "A----"<< s.c_str() << endl;
    }
};

class ColleagueB : public Colleague {
public:
    using Colleague::Colleague;
    void send() override {
        _mediator->deal(this);
    }
    void receive(string s) override {
        cout << "B----"<< s.c_str() << endl;
    }
};

class MediatorA : public Mediator {
public:
    void deal(Colleague* p) override {
        if (p == _from) {
            _from->receive("from--->to");
        } else {
            _to->receive("to--->from");
        }
    }
};

int main() {
    Mediator* mediator = new MediatorA();
    Colleague* p1 = new ColleagueA(mediator);
    Colleague* p2 = new ColleagueB(mediator);
    mediator->setColleague(p1, p2);
    p1->send();
    p2->send();
    delete p1;
    delete p2;
    delete mediator;
    return 0;
}

 10.解释者模式

提供评估语言的语法或表达式的方式。实现了一个表达式接口，该接口解释一个特定的上下文。被用在SQL解析、符号处理引擎等。

四、模式设计原则

1.设计原则

①面向对象设计模式：应对变化，提高复用的设计。

②设计模式要点：寻找变化点，然后再变化点处应用设计模式，从而来更好应对需求变化。

③设计模式应用不宜先入为主，没有一步到位的设计模式。

Tra220123
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++11 std::this_thread::sleep_for让我睡一会再干活
二进制君
03-28 2万+
我从linux C程序员转C++程序员提交的第一份代码里，我写了个线程，其中用到了一个睡眠函数sleep()，写完后提交到分支上让直属领导review。 他第一句话就和我说别用sleep函数，C++里用std::this_thread::sleep_for，用法自己去查。 我当时以为sleep会导致什么调度问题，后来上网查了下，发现原来不是，std::this_thread::sleep_for只不过是C++11 标准对各个平台的睡眠函数的封装，因为sleep是平台相关的api，它是类UNIX系统提供的，换
Windows下std::this_thread:sleep_for()休眠精度问题
ocfbnj的博客
12-27 4078
Windows下std::this_thread:sleep_for()休眠精度问题 最近在开发一个NES模拟器，想自己实现一个简单的像素游戏引擎用来渲染NES输出的图像。NES系统能输出60帧的图像，所以我希望游戏引擎能将帧率限制在60帧。最简单的方法就是用sleep控制每次主循环的时间。但同样的代码，在Mac OS和Windows上出现了不同的结果。 在Mac OS上，程序运行符合预期，可以稳定输出60帧，但在Windows上，程序运行变得非常慢，大概30多帧左右。经过几天的研究，发现是Windows下
std::this_thread::sleep_for
热门推荐
既然选择了远方 便只顾风雨兼程 - 永强
03-01 1万+
std::this_thread::sleep_for Defined in header <thread> - 定义于头文件 <thread> 1. std::this_thread::sleep_for template <class Rep, class Period> void sleep_for (const chrono::duration<Rep,Period>& rel_time); 阻塞当前线程执行，至少经过指定的 sleep_dur
C++多线程基础
最新发布
qq_55998987的博客
03-11 199
C++多线程
C++11多线程基础知识
06-19 1000
原文作者：aircraft 原文链接：https://www.cnblogs.com/DOMLX/p/10945309.html 1.创建一个简单的多线程案例： 首先导入#include<thread>---用于创建线程 其次导入#include<chrono>--用于时间延时 获取时间之类的 定义一个线程对象t1，这就自动创建了一个线程，参数就是你要线程去执行的函数，t1是变量名字 随便取 std::thread t1(func); 下面这里返回一个毫秒级别的.
C++11 多线程thread的休眠sleep_for chrono
zhuzitop的博客
04-26 7631
使用C++11中的thread和chrono来实现休眠控制. this_thread::sleep_for(seconds(2)); 除了seconds外，还可使用 std::chrono::nanoseconds std::chrono::microseconds std::chrono::milliseconds std::chrono::seconds std::chrono::minutes std::chrono::hours #include <chrono> #incl
设计模式总结.pdf
07-01
自己整理的关于设计模式的总结，有全部的设计模式介绍，以及常用的设计模式总结记忆，适合程序员面试前突击以及日常学习使用
Spring 设计模式总结1
08-04
Spring设计模式总结 在软件开发中，设计模式是解决常见问题的经验总结，它们为程序员提供了在特定场景下设计高效、可维护代码的蓝图。在Spring框架中，许多设计模式被广泛应用，以提升系统的灵活性和可扩展性。以下...
所有设计模式总结
06-14
上面总结用的是思维导图，（注意：需要用xmind软件打开）设计模式总结，分为三个大类型：创建型，结构型，行为型。总结了它们适用于解决什么问题，用了后所要达到的意图。
std::this_thread::sleep_for 使用
xiaojinger_123的博客
04-08 1万+
使用说明 std::this_thread::sleep_for函数是C11的休眠函数，表示当前线程休眠一段时间，休眠期间不与其他线程竞争CPU，根据线程需求，等待若干时间。 由于是一个跨平台的函数，因此在代码中大量应用，避免了在不同平台之间所以通过宏定义编译问题。在windows下，可以简单替代Sleep, 在Linux下，替代usleep 调用例子 头文件定义： #include <thread> std::this_thread::sleep_for(std::chrono::millis
C++线程学习1，线程创建的多种方式
Ckuanfeng的博客
12-06 2404
thread的生命周期和线程的等待和分离
c++ 之 std::this_thread::yield 与std::this_thread::sleep_for
学之知之的博客
11-30 1万+
std::this_thread::yield：　当前线程放弃执行，操作系统调度另一线程继续执行。即当前线程将未使用完的“CPU时间片”让给其他线程使用，等其他线程使用完后再与其他线程一起竞争"CPU"。 std::this_thread::sleep_for：　表示当前线程休眠一段时间，休眠期间不与其他线程竞争CPU，根据线程需求，等待若干时间。 this_thread 包装了一组可以访问当前...
std::this_thread::sleep_for 与std::this_thread::yield的区别
Sandy_WYM_的博客
10-30 1万+
std::this_thread::yield：　当前线程放弃执行，操作系统调度另一线程继续执行。即当前线程将未使用完的“CPU时间片”让给其他线程使用，等其他线程使用完后再与其他线程一起竞争"CPU"。 std::this_thread::sleep_for：　表示当前线程休眠一段时间，休眠期间不与其他线程竞争CPU，根据线程需求，等待若干时间。 两者具有相似的作用，但使用目的不同。例如以下两个...
通过sleep_for来使线程睡眠一定的时间
Jake2549794390的博客
03-13 3751
#include #include #include using namespace std; int main() {     mutex m;     thread t1([&m]()     {         this_thread::sleep_for(chrono::seconds(10));//通过sleep_for来使线程睡眠一定的时间         f
C++11当前线程this_thread实战
实践求真知
04-13 7282
一点睛 C++11提供了一个命名空间this_thread来引用当前线程，该命名空间有4个有用的函数，get_id,yield,sleep_until,sleep_for。 get_id是用来获取线程ID的。 其他3个函数都和时间相关，下面分别进行实战演练。 二yield让出CPU时间 1点睛 yield函数：调用该函数的线程放弃执行，回到就绪态。 我们创建10个线程，每个线程...
boost::this_thread::sleep_for()死锁
金庆的专栏
09-24 1万+
boost::this_thread::sleep_for()会死锁（金庆的专栏）发现睡眠1ms很容易死锁。boost::this_thread::sleep_for(boost::chrono::milliseconds(1)).Boost 1.54.0以下代码很可能重现死锁：#include "stdafx.h"#include #include using namespace std;voi
设计模式总结：建型与结构型模式详解
"这篇文章除了标题'设计模式总结(1)'，还涉及了设计模式的分类，包括创建型、结构型和行为型设计模式的概述。文章着重讲解了创建型模式中的SingletonPattern（单例模式），并对其意图和适用性进行了详细描述，同时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值