（c++笔记）第三十三节课：设计模式（部分）

已于 2022-08-04 09:42:24 修改
阅读量329 收藏
点赞数
分类专栏： c++ 笔记 文章标签： c++ 设计模式 开发语言
于 2022-08-01 21:19:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xaf21/article/details/126064095
版权
笔记 同时被 2 个专栏收录
30 篇文章 2 订阅
订阅专栏
c++
16 篇文章 0 订阅
订阅专栏

目录

一设计模式

## 1.1 设计原则

例1：

例2：

二 单例模式

2.1懒汉式

## 2.2饿汉式

三工厂模式

## 3.1抽象工厂模式

四 建造者模式

4.1简单版

4.2建造者模式

五原型模式

 六组合模式

七代理模式

 八装饰模式

九适配器模式

# 一 享元模式

# 二 桥接模式

# 三 外观模式

# 四 观察者模式

一设计模式

```
创建型模式：
    工厂模式，抽象工厂模式，单例模式，建造者模式等
结构型模式：
    关注类和对象的组合，继承被用来组合接口和定义组合对象
    适配器模式，桥接模式 组合模式，外观模式 等
行为型模式：
    关注对象之间的通信
```

## 1.1 设计原则

```
1.开放封闭原则：所有新增的功能不是通过类的改动来实现，而是通过新增代码来实现。
2.依赖倒置原则：依赖与抽象，不依赖于具体的实现
```

例1：

```c++
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
class BankWoker
{
    public: 
        virtual void Worker() = 0;
};
class GetMoney :public BankWoker
{
public:
    void Worker()
    {
        cout << "取款业务" << endl;
    }
};
class SaveMoney :public BankWoker
{
public:
    void Worker()
    {
        cout << "存款业务" << endl;
    }
};
int main(void)
{
    BankWoker *b = new GetMoney;
    b->Worker();
    delete b;
    b = new SaveMoney;
    b->Worker();
    return 0;
}
```

例2：

```c++
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
class HardDisk
{
public:
    virtual void work() = 0;
};
class CPU
{
public:
    virtual void work() = 0;
};
class AHardDisk :public HardDisk
{
public:
    void work()
    {
        cout << "hard disk work..." << endl;
    }
};
class ACPU:public CPU
{
public:
    virtual void work()
    {
        cout << "ACPU WORK..." << endl;
    }
};
class Computer
{
private:
    HardDisk *m_h;
    CPU *m_c;
public:
    Computer(HardDisk *h, CPU *c)
    {
        m_h = h;
        m_c = c;
    }
    void work()
    {
        m_h->work();
        m_c->work();
    }
};
int main(void)
{
    CPU *c = new ACPU;
    HardDisk *h = new AHardDisk;
    Computer com(h,c);
    com.work();
    return 0;
}
```

二 单例模式

2.1懒汉式

```c++
保证一个类只能生成唯一的实例对象，也就是说，在整个程序中，只存在一个实例对象。
```

```c++
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <unistd.h>
#include <pthread.h>
pthread_mutex_t mutex;
using namespace std;
class Singleton
{
private:
    static Singleton *m_instance;
    static int count;
    Singleton()
    {
        
    }
public:
    static Singleton *GetInstance()
    {
        if (NULL == m_instance)
        {
            cout<<"m_instance = NULL!"<<endl;
            usleep(1000);
            m_instance = new Singleton;  //全程只分配一次空间（懒汉式）
        }
        count++;
        return m_instance;
    }
    static int GetCount()
    {
        return count;
    }
    void Release()
    {
        count--;
        if (count == 0 && m_instance != NULL)
        {
            delete m_instance;
        }
    }
};
Singleton *Singleton::m_instance = NULL;
int Singleton::count = 0;
void* CreateInstance(void *arg)
{
    pthread_mutex_lock(&mutex);
    Singleton *s = Singleton::GetInstance();
    cout<<s<<endl;
    pthread_mutex_unlock(&mutex);
}
int main(void)
{
    /*Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();
    Singleton *s3 = Singleton::GetInstance();
    Singleton *s4 = Singleton::GetInstance();
    Singleton *s5 = Singleton::GetInstance();
    Singleton *s6 = Singleton::GetInstance();
    cout << Singleton::GetCount() << endl;
    if (s1 == s2)
    {
        cout << "equal" << endl;
    }*/
    pthread_mutex_init(&mutex,NULL);
    pthread_t tid[10];
    int ret;
    for(int i = 0 ; i < 10;i++)
    {
        ret = pthread_create(&tid[i],NULL,CreateInstance,NULL);
        if(ret != 0)
        {
            perror("pthread_create");
        }
    }
    void *status;
    for(int i = 0;  i < 10;i++)
    {
        pthread_join(tid[i],&status);
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}
```

## 2.2饿汉式

```c++
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <unistd.h>
#include <pthread.h>
pthread_mutex_t mutex;
using namespace std;
class Singleton
{
private:
    static Singleton *m_instance;
    static int count;
    Singleton()
    {
        
    }
public:
    static Singleton *GetInstance()
    {
        /*if (NULL == m_instance)
        {
            cout<<"m_instance = NULL!"<<endl;
            usleep(1000);
            m_instance = new Singleton;  //全程只分配一次空间（懒汉式）
        }*/
        count++;
        return m_instance;
    }
    static int GetCount()
    {
        return count;
    }
    void Release()
    {
        count--;
        if (count == 0 && m_instance != NULL)
        {
            delete m_instance;
        }
    }
};
Singleton *Singleton::m_instance = new Singleton;  //先分配内存空间（饿汉式）
int Singleton::count = 0;
int main(void)
{
    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();
    Singleton *s3 = Singleton::GetInstance();
    Singleton *s4 = Singleton::GetInstance();
    Singleton *s5 = Singleton::GetInstance();
    Singleton *s6 = Singleton::GetInstance();
    cout << Singleton::GetCount() << endl;
    if (s1 == s2)
    {
        cout << "equal" << endl;
    }

    return 0;
}
```

三工厂模式

```c++
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <windows.h>
using namespace std;
class Fruit
{
public:
    virtual void show() = 0;
};
class Apple :public Fruit
{
public:
    void show()
    {
        cout << "this is apple" << endl;
    }
};
class Banana :public Fruit
{
public:
    void show()
    {
        cout << "this is Banana" << endl;
    }
};
class Pear :public Fruit
{
public:
    void show()
    {
        cout << "this is Pear" << endl;
    }
};
class Factory
{
public:
    virtual Fruit *Create() = 0;
};
class AppleFactory :public Factory
{
public:
    Fruit *Create()
    {
        return new Apple;
    }
};
class BananaFactory :public Factory
{
public:
    Fruit *Create()
    {
        return new Banana;
    }
};
class PearFactory :public Factory
{
public:
    Fruit *Create()
    {
        return new Pear;
    }
};
int main(void)
{
    Factory *f = new AppleFactory;   
    Fruit *fruit;
    fruit = f->Create();
    fruit->show();
    delete f;
    delete fruit;

    f = new BananaFactory;
    fruit = f->Create();
    fruit->show();
    return 0;
}
```

## 3.1抽象工厂模式

```c++ 
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <windows.h>
using namespace std;
class Fruit
{
public:
    virtual void show() = 0;
};
class NorthApple :public Fruit
{
public:
    void show()
    {
        cout << "this is NorthApple" << endl;
    }
};
class SouthApple :public Fruit
{
public:
    void show()
    {
        cout << "this is SouthApple" << endl;
    }
};
class NorthBanana :public Fruit
{
public:
    void show()
    {
        cout << "this is NorthBanana" << endl;
    }
};
class SouthBanana :public Fruit
{
public:
    void show()
    {
        cout << "this is SouthBanana" << endl;
    }
};
class NorthPear :public Fruit
{
public:
    void show()
    {
        cout << "this is NorthPear" << endl;
    }
};
class SouthPear :public Fruit
{
public:
    void show()
    {
        cout << "this is SouthPear" << endl;
    }
};

class Factory
{
public:
    virtual Fruit *CreateApple() = 0;
    virtual Fruit *CreateBanana() = 0;
    virtual Fruit *CreatePear() = 0;
};
class NorthFactory :public Factory
{
public:
    virtual Fruit *CreateApple()
    {
        return new NorthApple;
    }
    virtual Fruit *CreateBanana()
    {
        return new NorthBanana;
    }
    virtual Fruit *CreatePear()
    {
        return new NorthPear;
    }
};
class SouthFactory :public Factory
{
public:
    virtual Fruit *CreateApple()
    {
        return new SouthApple;
    }
    virtual Fruit *CreateBanana()
    {
        return new SouthBanana;
    }
    virtual Fruit *CreatePear()
    {
        return new SouthPear;
    }
};
void Create(Factory *f)
{
    Fruit *fruit;
    fruit = f->CreateApple();
    fruit->show();
    delete fruit;
    fruit = f->CreateBanana();
    fruit->show();
    delete fruit;
}
int main(void)
{
    Factory *f = new SouthFactory;
    Create(f);
    delete f;
    f = new NorthFactory;
    Create(f);

    Fruit *f1 = new SouthApple;
    f1->show();
    return 0;
}
```

四 建造者模式

4.1简单版

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
//#include<windows.h>
using namespace std;
class House
{
    private:
        string wall;
        string window;
        string door;
    public:
        void SetWall()
        {
            wall="WALL";
        }
        void SetWindow()
        {
            window="WINDOW";
        }
        void SetDoor()
        {
            door="DOOR";
        }
};
class Builder
{
    private:
        House *house;
    public:
        Builder(House *h)
        {
            house=h;
        }
        void Constructor()
        {
            house->SetDoor();
            house->SetWall();
            house->SetWindow();
        }
};
int main()
{
    House *h=new House;
    Builder *b=new Builder(h);
    b->Constructor();
    return 0;
}

4.2建造者模式

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
class House
{
    private:
        string wall;
        string window;
        string door;
    public:
        void SetWall(string w)
        {
            wall=w;
        }
        void SetWindow(string w)
        {
            window=w;
        }
        void SetDoor(string d)
        {
            door=d;
        }
};
class Builder
{
    protected:
        House *house;
    public:
        virtual void Constructor()=0;
};
class CommonBuilder :public Builder 
{
    public:
        CommonBuilder(House *h)
        {
            house=h;
        }
        void Constructor()
        {
            house->SetDoor("DOOR");
            house->SetWall("WALL");
            house->SetWindow("WINDOW");
        }
};
class VilliaBuilder :public Builder 
{
    public:
        VilliaBuilder(House *h)
        {
            house=h;
        }
        void Constructor()
        {
            house->SetDoor("VILLIA-DOOR");
            house->SetWall("VILLIA-WALL");
            house->SetWindow("VILLIA-WINDOW");
        }
};
class Designer
{
    private:
        Builder *b;
    public:
        void SetBuilder(Builder *Builder)
        {
            b=Builder;
        }
        void Constructor()
        {
            b->Constructor();
        }
};
int main()
{
    Designer *d=new Designer;
    House *h=new House;
    Builder *b=new CommonBuilder(h);
    d->SetBuilder(b);
    d->Constructor();
    delete b;
    b=new VilliaBuilder(h);
    d->SetBuilder(b);
    d->Constructor();
    return 0;
}

五原型模式

#include<iostream>
#include<string>
using namespace std;
class Person
{
protected:
    int age;
    string name;
public:
    Person(){}
    Person(string n,int a)
    {
        name=n;
        age=a;
    }
    virtual Person *clone()=0;
    virtual void show()=0;
};
class Student:public Person
{
    private:
        int id;
    public:
        Student(){}
        Student(string n,int a,int i):Person(n, a)
        {
            id=i;
        }
        void show()
        {
            cout<<name<<" "<<age<< " "<<id<<endl;
        }
        Person *clone()
        {
            Student *tmp=new Student;
            *tmp=*this;
            return 0;
        }
};
int main()
{
    Person *p1=new Student("aa",29,100);
    Person *p2=p1->clone();
    p2->show();
    return 0;
}

 六组合模式

  • 又称为部分整体模式

#include<iostream>
#include<string>
#include<list>
using namespace std;
class iFile//虚函数
{
    public:
        virtual int Add(iFile *file)=0;
        virtual string GetName()=0;
        virtual int remove(iFile *fie)=0;
        virtual list<iFile*> *GetChild()=0;
};
class File:public iFile
{
    private:
        string name;
    public:
        File(string n)
        {
            name=n;
        }
        virtual int Add(iFile *file)
        {
            return -1;
        }
        virtual string GetName()
        {
            return name;
        }
        virtual int remove(iFile *file)
        {
            return -1;
        }
        virtual list<iFile*> *GetChild()
        {
            return nullptr;
        }
};
class Dir:public iFile
{
private:
    string name;
    list<iFile*> *l;
public:
    Dir(string n)
    {
        name =n;
        l=new list<iFile*>;
    }
    virtual int Add(iFile *file)
    {
        l->emplace_back(file);
        return -1;
    }
    virtual string GetName()
    {
        return name;
    }
    virtual int remove(iFile *file)
    {
        l->remove(file);
        return -1;
    }
    virtual list<iFile*> *GetChild()
    {
        return l;
    }
};
void show(iFile *root,int gap)
{
    for(int i=0;i<gap;i++)
    {
        cout<<"---";
    }
    if(root!=NULL)
    {
        cout<<root->GetName()<<endl;
    }
    else
    {
        return;
    }
    auto l=root->GetChild();
    if(l!=nullptr)
    {
        for(auto it=l->begin();it!=l->end();it++)
        {
            show((*it),gap+1);
        }
    }
};
int main()
{
    iFile *dir1=new Dir("day1");
    iFile *dir2=new Dir("day2");
    iFile *dir3=new Dir("day3");

    iFile *file1=new File("1.c");
    iFile *file2=new File("2.c");
    iFile *file3=new File("3.c");
    iFile *file4=new File("4.c");
    iFile *file5=new File("5.c");
    iFile *file6=new File("9.c");
    iFile *file7=new File("7.c");

    dir2->Add(file1);
    dir2->Add(file2);
    dir2->Add(file3);
    dir2->Add(file4);
    dir2->Add(file5);
    dir2->Add(file6);

    dir3->Add(file1);
    dir3->Add(file3);
    dir3->Add(file5);
    dir3->Add(file7);
    dir3->Add(file2);

    dir1->Add(dir2);
    dir1->Add(dir3);
    show(dir1,0);
    return 0;
}

七代理模式

#include<iostream>
#include<string>
#include<list>
using namespace std;
class Sale
{
    public:
        virtual void SaleBook()=0;
};
class BookStore:public Sale
{
    private:
        static int count;
    public:
        void SaleBook()
        {
            cout<<"书店卖书。。。"<<endl;
            count++;
        }
        static int GetCount()
        {
            return count;
        }
};
class TaoBao:public Sale
{
    private:
        Sale *sale;
    public:
        TaoBao(Sale *s)
        {
            sale=s;
        }
        void SaleBook()
        {
            cout<<"网上卖书。。。"<<endl;
            sale->SaleBook();
        }
};
int BookStore::count=0;
int main()
{
    Sale *store=new BookStore();
    Sale *taobao=new TaoBao(store);
    taobao->SaleBook();
    store->SaleBook();
    cout<<BookStore::GetCount()<<endl;
    return 0; 
}

 八装饰模式

#include<iostream>
#include<string>
#include<list>
using namespace std;
class Phone
{
    public:
        virtual void function()=0;
};
class CallPhone:public Phone
{
    public:
        void function()
        {
            cout<<" telephone"<<endl;
        }
};
class PhotoPhone:public Phone
{
    private:
        Phone *phone;
    public:
        PhotoPhone(Phone *p)
        {
            phone=p;
        }
        void function()
        {
            phone->function();
            cout<<"take photoes phone"<<endl;
        }

};
class MusicPhone:public Phone
{
    private:
        Phone *phone;
    public:
        MusicPhone(Phone *p)
        {
            phone=p;
        }
        void function()
        {
            phone->function();
            cout<<"lisen music phone"<<endl;
        }
};
class Iphone:public Phone
{
    private:
        Phone *phone;
    public:
        Iphone(Phone *p)
        {
            phone=p;
        }
        void function()
        {
            phone->function();
            cout<<"go online phone"<<endl;
        }
};
int main()
{
    cout<<"**********call phone**********"<<endl;
    Phone *callphone=new CallPhone();
    callphone->function();
    cout<<"**********take picture**********"<<endl;
    Phone *photophone=new PhotoPhone(callphone);
    photophone->function();
    cout<<"**********liste nmusic**********"<<endl;
    Phone *musicphone=new MusicPhone(photophone);
    musicphone->function();
    cout<<"**********go online**********"<<endl;
    Phone *iphone=new Iphone(musicphone);
    iphone->function();
    return 0;
}

九适配器模式

#include<iostream>
using namespace std;
class Current
{
    public:
        virtual int GetCurrent()=0;
};
class Current_220:public Current
{
    public:
        int GetCurrent()
        {
            return 220;
        }
};
class Adapter:public Current
{
    private:
        Current *current;
    public:
        Adapter(Current *c)
        {
            current=c;
        }
        int GetCurrent()
        {
            if(current->GetCurrent()==220)
            {
                return 12;
            }
            else
            {
                return 5;
            }
        }
};
class Phone
{
    private:
        Current *current;
    public:
        Phone(Current *c)
        {
            current=c;
        }
        void start()
        {
            if(current->GetCurrent()==220)
            {
                cout<<"boom....."<<endl;;
            }
            else
            {
                cout<<"chaging......."<<endl;
            }
        }
};
int main()
{
    Current *c=new Current_220;
    Current *a=new Adapter(c);
    Phone *p=new Phone(a);
    p->start();
    return 0;
}

# 一 享元模式

主要通过与其它类对象共享数据来减少内存的使用
适用情况:有大量对象需要重复创建的时候，或者以共享内存的方式

 

```c++
#include <iostream>
#include <map>
#include <string>
using namespace std;
class Student
{
private:
    string name;
    int age;
    int id;
public:
    Student()
    {
    }
    Student(string n, int a, int i)
    {
        name = n;
        age = a;
        id = i;
    }
    string GetName()
    {
        return name;
    }
    int GetAge()
    {
        return age;
    }
    int GetId()
    {
        return id;
    }
};
class FwFactory
{
private:
    multimap<int, Student*> *m;
public:
    FwFactory()
    {
        m = new multimap<int, Student *>;
    }
    ~FwFactory()
    {
        while (!m->empty())
        {
            Student *tmp = m->begin()->second;
            delete tmp;
            m->erase(m->begin());
        }
        delete m;
    }
    void GetPerson(int id)
    {
        string name;
        int age;
        multimap<int, Student *>::iterator it;
        it = m->find(id);
        if (it == m->end())
        {
            cout << "input the name age..." << endl;
            cin >> name >> age;
            Student *s = new Student(name, age, id);
            m->emplace(make_pair(id, s));
        }
        else
        {
            Student *s = it->second;
            cout << s->GetName() << " " << s->GetAge() << " " << s->GetId() << endl;
        }
    }

};
int main(void)
{
    FwFactory *f = new FwFactory;
    f->GetPerson(1);
    f->GetPerson(2);
    f->GetPerson(3);
    cout << "**************" << endl;

    f->GetPerson(2);
    return 0;
}
```

# 二 桥接模式

 

将抽象和实现分离，使他们可以独立变化。
基于类的最小设计原则

```c++
#include <iostream>
#include <map>
#include <string>
using namespace std;

class Phone
{
public:
    virtual void func() = 0;
};
class Iphone :public Phone
{
public:
    void func()
    {
        cout << "this is IPHONE...." << endl;
    }
};
class HUAWEI :public Phone
{
public:
    void func()
    {
        cout << "this is HUAWEI" << endl;
    }
};
class Soft  //实现两种从产品的链接，把不同的产品剥离出来，耦合度低
{
protected:
    Phone *phone;
public:
    virtual void func() = 0;
};
class QQ :public Soft 
{
public:
    QQ(Phone *p)
    {
        phone = p;
    }
    void func()
    {
        phone->func();
        cout << "this is QQ" << endl;
    }
};
class Vchat :public Soft
{
public:
    Vchat(Phone *p)
    {
        phone = p;
    }
    void func()
    {
        phone->func();
        cout << "this is Vchat" << endl;
    }
};
int main(void)
{
    Phone *p = new Iphone;
    Soft *a = new QQ(p);
    a->func();
    return 0;
}
```

# 三 外观模式

提供一个简单一致的界面，为了系统中统一的一套接口

```c++
#include <iostream>
#include <map>
#include <string>
using namespace std;

class SystemA
{
public:
    void func()
    {
        cout << "this is A" << endl;
    }
};
class SystemB
{
public:
    void func()
    {
        cout << "this is B" << endl;
    }
};
class SystemC
{
public:
    void func()
    {
        cout << "this is C" << endl;
    }
};
class Facade
{
private:
    SystemA *a;
    SystemB *b;
    SystemC *c;
public:
    Facade()
    {
        a = new SystemA;
        b = new SystemB;
        c = new SystemC;
    }
    ~Facade()
    {
        delete a;
        delete b;
        delete c;
    }
    void func()
    {
        a->func();
        b->func();
        c->func();
    }
};
int main(void)
{
    Facade *f = new Facade;
    f->func();
    return 0;
}
```

# 四 观察者模式

当对象存在一对多的关系的时候，使用观察者模式，当一个对象被修改的时候，则会自动通知
依赖他的所有对象。

```c++
#include <iostream>
#include <map>
#include <string>
#include <list>
using namespace std;
class Infom;
class Observer  //观察者 员工
{
public:
    virtual void Subscribe(Infom *i) = 0;  //订阅
    virtual void UnSubscribe(Infom *i) = 0;  //取消订阅
    virtual void Update(string str) = 0;  //更新状态
};
class Infom  //通知者  秘书
{
public:
    virtual void Add(Observer *o) = 0;
    virtual void Remove(Observer *o) = 0;
    virtual void Notify(string str) = 0;
};
class Secretary :public Infom
{
private:
    list <Observer *> l;
public:
    void Add(Observer *o)
    {
        l.emplace_back(o);
    }
    void Remove(Observer *o)
    {
        l.remove(o);
    }
    void Notify(string str)
    {
        for (auto &it : l)
        {
            it->Update(str);
        }
    }
};
class Staff :public Observer
{
public:
    virtual void Subscribe(Infom *i)  //订阅
    {
        i->Add(this);
    }
    virtual void UnSubscribe(Infom *i) //取消订阅
    {
        i->Remove(this);
    }
    virtual void Update(string str)  //更新状态
    {
        if (str == "WARNING")
        {
            cout << "boss is comming" << endl;
        }
        else
        {
            cout << "continue to play games" << endl;
        }
    }
};
int main(void)
{
    Infom *i = new Secretary;
    Observer *o1 = new Staff;
    Observer *o2 = new Staff;
    Observer *o3 = new Staff;
    Observer *o4 = new Staff;
    o1->Subscribe(i);
    o2->Subscribe(i);
    o3->Subscribe(i);
    o4->Subscribe(i);

    i->Notify("WARNING");
    return 0;
}
```

xaf21
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值