设计模式

1、设计模式基本原则

1、创建型模式：通过和对象的创建有关（5种）
2、结构型模式：组合类和对象（7种）
3、行为型模式：类或对象的交互（11种）

基本原则---->书290
1、开放封闭原则：类的改动是通过增加代码进行的，而不是修改原代码
2、依赖倒置原则：依赖于抽象（接口），不依赖于具体的类
3、接口隔离原则：不应该强迫客户的程序依赖他们不需要的接口
4、里式替换原则：任何抽象类出现的地方都可以用它的实现类替换
5、优先使用组合而不是继承原理：如果使用继承，会导致父类的任何变换都可能影响到子类的行为
6、迪米特法则：一个对象应该尽可能的对其他对象少了解，从而降低对象之间的耦合，提高可维持性。

#include <iostream>

using namespace std;

//开放封闭原则：通过代码的增加进行类的改动，而不是修改源代码
class absBank
{
public:
    virtual void work() = 0;
};
//银行工作人员
class Bank_save:public absBank
{
    void work()
    {
        cout<<"存钱"<<endl;
    }
};
//银行工作人员
class Bank_get:public absBank
{
    void work()
    {
        cout<<"取钱"<<endl;
    }
};

//新增功能----------------------------------
class Bank_transform:public absBank
{
    void work()
    {
        cout<<"转账"<<endl;
    }
};

int main1(int argc, char *argv[])
{
    absBank *pa1 = new Bank_save;
    pa1->work();

    absBank *pa2 = new Bank_get;
    pa2->work();

    absBank *pa3 = new Bank_transform;
    pa3->work();

    return 0;
}

2、单例模式

1、懒汉

#include <iostream>

using namespace std;

//单例模式---->懒汉版
//1、将构造函数设置成私有
//2、写一个创建对象的指针--->返回值是对象指针（函数要写出静态函数，需要设置成静态变量）
//3、初始化静态变量
//4、要一个计数的句柄（静态变量，在外部初始化）
//5、写一个释放的函数（通过count和指针判断是否应该是否指向空间）
class singleton
{
private:
    singleton()
    {
    }
public:
    static singleton *GetInstance()
    {
        handle_count++;
        if(m_instancce == nullptr)
            m_instancce = new singleton;
        return m_instancce;
    }
    static void Release()
    {
        if(handle_count>0)
            handle_count--;
        if(handle_count == 0 && m_instancce != nullptr)
        {
            delete m_instancce;
            m_instancce =nullptr;
        }
    }
    void show()
    {
        cout<<handle_count<<endl;
    }

private:
    static int handle_count;
    static singleton *m_instancce;
};
int singleton::handle_count = 0;
singleton *singleton::m_instancce = nullptr;

int main3()
{
    singleton* s1 = singleton::GetInstance();
    singleton* s2 = singleton::GetInstance();
    singleton* s3 = singleton::GetInstance();
    singleton* s4 = singleton::GetInstance();

    cout<<s1<<endl;
    cout<<s2<<endl;
    cout<<s3<<endl;
    cout<<s4<<endl;
    s1->show();

    s2->Release();
    s3->Release();
    s4->Release();
    s1->show();

    return 0;
}

2、

#include <iostream>

using namespace std;
//单例模式---->饿汉版
class singleton1
{
private:
    singleton1()
    {
    }
public:
    static singleton1 *GetInstance()
    {
        handle_count++;
        return m_instancce;
    }
    static void Release()
    {
        if(handle_count>0)
            handle_count--;
        if(handle_count == 0 && handle_count != nullptr)
        {
            delete handle_count;
            m_instancce =nullptr;
        }
    }
    void show()
    {
        cout<<handle_count<<endl;
    }

private:
    static int handle_count;
    static singleton *m_instancce;
};
int singleton1::handle_count = 0;
singleton *singleton1::m_instancce = new singleton1;


int main3()
{
    singleton* s1 = singleton::GetInstance();
    singleton* s2 = singleton::GetInstance();
    singleton* s3 = singleton::GetInstance();
    singleton* s4 = singleton::GetInstance();

    cout<<s1<<endl;
    cout<<s2<<endl;
    cout<<s3<<endl;
    cout<<s4<<endl;
    s1->show();

    s2->Release();
    s3->Release();
    s4->Release();
    s1->show();

    return 0;
}

3、带锁的

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

using namespace std;

//单例模式---->懒汉版--->并不能保证并发的时候只有一个对象产生
class singleton
{
private:
    singleton()
    {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        cout<<"构造函数"<<endl;
    }
public:
    static singleton *GetInstance()
    {
        //上锁1
        mutex.lock();
        if(m_instancce == nullptr)
            m_instancce = new singleton;
        mutex.unlock();

        //上锁2
//        if(m_instancce == nullptr)
//        {
//            std::unique_lock<std::mutex> lock(mutex);
//            if(m_instancce == nullptr)
//                m_instancce = new singleton;
//        }

        handle_count++;
        return m_instancce;
    }
    static void Release()
    {
        if(handle_count>0)
            handle_count--;
        if(handle_count == 0 && m_instancce != nullptr)
        {
            delete m_instancce;
            m_instancce =nullptr;
        }
    }
    void show()
    {
        cout<<handle_count<<endl;
    }

private:
    static int handle_count;
    static singleton *m_instancce;
    static std::mutex mutex;
};
int singleton::handle_count = 0;
singleton *singleton::m_instancce = nullptr;
std::mutex singleton::mutex;
void func(int i)
{
    cout<<i<<"号线程"<<endl;
    singleton* pa = singleton::GetInstance();
}

int main4()
{
    vector<std::thread> v;
    for(int i = 0;i < 5;i++)
    {
        v.push_back(std::thread (func,i+1));
    }
    for(int i = 0;i < 5;i++)
    {
        v[i].join();
    }


    return 0;
}

2、简单工厂

#include <iostream>
#include <string>

using namespace std;

//简单工厂
class Clothes
{
public:
    virtual void show() = 0;
};

class T_shirt:public Clothes
{
public:
    void show()
    {
        cout<<"T恤"<<endl;
    }
};

class Jacket:public Clothes
{
public:
    void show()
    {
        cout<<"夹克"<<endl;
    }
};

class Factory
{
public:
    Clothes *creat(string name)
    {
        if(name == "T恤")
            return new T_shirt;
        if(name == "夹克")
            return new Jacket;
    }
};


int main5()
{
    Factory *pf = new Factory;
    Clothes *pc1 = pf->creat("夹克");
    pc1->show();
    Clothes *pc2 = pf->creat("T恤");
    pc2->show();

    return 0;
}