C++ 设计模式使用

本人目前项目中用到的设计模式做下总结， 如果错误，麻烦帮忙指出改正;

1. 简单工厂模式， 简单点来说就是工厂可以生产各种类型产品，客户Jungle需要时可以向工厂提供产品参数，工厂根据产品参数生产对应产品，客户Jungle并不需要关心产品的生产过程细节，直接上代码：

#ifndef __SIMPLE_FACTORY__
#define __SIMPLE_FACTORY__

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

//抽象产品类AbstractProduct
class AbstractSportProduct
{
public:
    AbstractSportProduct(){

    }
    virtual ~AbstractSportProduct()
    {
        printf("~AbstractSportProduct");
    };
    //抽象方法：
    // virtual void printName(){};
    virtual void printName() = 0;
    // virtual void play(){};
    virtual void play() = 0;
};

//具体产品类Basketball
class Basketball :public AbstractSportProduct
{
public:
    Basketball(){
        printName();
        play();
    }
    ~Basketball()
    {

    }
    //具体实现方法
    void printName(){
        printf("Jungle get Basketball\n");
    }
    void play(){
        printf("Jungle play Basketball\n");
    }
};

//具体产品类Football
class Football :public AbstractSportProduct
{
public:
    Football(){
        printName();
        play();
    }
    ~Football()
    {

    }
    //具体实现方法
    void printName(){
        printf("Jungle get Football\n");
    }
    void play(){
        printf("Jungle play Football\n");
    }
};

//具体产品类Volleyball
class Volleyball :public AbstractSportProduct
{
public:
    Volleyball(){
        printName();
        play();
    }
    ~Volleyball()
    {
        
    }
    //具体实现方法
    void printName(){
        printf("Jungle get Volleyball\n");
    }
    void play(){
        printf("Jungle play Volleyball\n");
    }
};

class Factory
{
public:
    std::shared_ptr<AbstractSportProduct> getSportProduct(string productName)
    {
        std::shared_ptr<AbstractSportProduct> pro;
        if (productName == "Basketball"){
            pro = std::shared_ptr<AbstractSportProduct>(new Basketball());
        }
        else if (productName == "Football"){
            pro = std::shared_ptr<AbstractSportProduct>(new Football());
        }
        else if (productName == "Volleyball"){
            pro = std::shared_ptr<AbstractSportProduct>(new Volleyball());
        }
        return pro;
    }
};


#endif //__SIMPLE_FACTORY__





#include <iostream>
#include <memory>
#include "SimpleFactory.h"

int main()
{
    printf("简单工厂模式\n");
    
    //定义工厂类对象
    std::shared_ptr<Factory> fac = std::make_shared<Factory>();
    // std::shared_ptr<AbstractSportProduct> product = std::shared_ptr<AbstractSportProduct>(fac->getSportProduct("Basketball"));
    std::shared_ptr<AbstractSportProduct> product = fac->getSportProduct("Basketball");
    
    fac = std::make_shared<Factory>();
    product = fac->getSportProduct("Football");
    // product = std::shared_ptr<AbstractSportProduct>(fac->getSportProduct("Football"));

    fac = std::make_shared<Factory>();
    product = fac->getSportProduct("Volleyball");    
    // product = std::shared_ptr<AbstractSportProduct>(fac->getSportProduct("Volleyball"));    
　　
　　getchar();

    return 0;
}

 

2. 抽象工厂模式

抽象工厂跟简单工厂有相似的结构，但是不一样的是抽象工厂中生产的产品会有多种类型，这些产品可根据实际的场景需要来定义;  直接上代码:

#pragma once

#include <iostream>
#include <string>
#include <memory>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

using namespace std;

#define     SINGLE_FACTORY_MODE          0

// 座椅
class AbsSeat
{
public:
    AbsSeat(){}

    virtual ~AbsSeat()
    {
        printf("~AbsSeat.\n");
    }

    virtual void print(){}

    virtual void show(){}

};


class HuaWeiSeat : public AbsSeat
{
public:
    HuaWeiSeat(){
        printf("HuaWeiSeat.\n");
    }
    ~HuaWeiSeat(){
        printf("~HuaWeiSeat.\n");
    }

    void print()
    {
        printf("HuaWeiSeat print.\n");
    }

    void show()
    {
        printf("HuaWeiSeat show.\n");
    }

};


class BMWSeat : public AbsSeat
{
public:
    BMWSeat(){
        printf("BMWSeat.\n");
    }
    ~BMWSeat(){
        printf("~BMWSeat.\n");
    }

    void print()
    {
        printf("BMWSeat print.\n");
    }

    void show()
    {
        printf("BMWSeat show.\n");
    }
};



// 轮胎
class AbsTire
{
public:
    AbsTire(){}

    virtual ~AbsTire()
    {
        printf("~AbsTire.\n");
    }

    virtual void print(){}

    virtual void repair(){}

};



class HuaWeiTire : public AbsTire
{
public:
    HuaWeiTire(){
        printf("HuaWeiTire.\n");
    }

    ~HuaWeiTire()
    {
        printf("~HuaWeiTire.\n");
    }

    void print()
    {
        printf("HuaWeiTire print.\n");
    }

    void repair()
    {
        printf("HuaWeiTire repair.\n");
    }

};


class BMWTire : public AbsTire
{
public:
    BMWTire(){
        printf("BMWTire.\n");
    }
    ~BMWTire()
    {
        printf("~BMWTire.\n");
    }

    void print()
    {
        printf("BMWTire print.\n");
    }

    void repair()
    {
        printf("BMWTire repair.\n");
    }
};



/**
 * @brief The AbsFactory class                  工厂基类
 */
class AbsFactory
{
public:
    AbsFactory(){}

    virtual ~AbsFactory()
    {
        printf("~AbsFactory\n");
    }

    virtual unique_ptr<AbsSeat> createSeat()
    {
        return nullptr;
    }

    virtual unique_ptr<AbsTire> createTire()
    {
        return nullptr;
    }

};


/**
 * @brief The HuaWeiFactoy class                华为汽车工厂
 */
class HuaWeiFactoy : public AbsFactory
{
public:
    HuaWeiFactoy()
    {
        printf("HuaWeiFactoy.\n");
    }

    ~HuaWeiFactoy()
    {
        printf("~HuaWeiFactoy.\n");
    }

    unique_ptr<AbsSeat> createSeat()
    {
        printf("create Huawei Seat.\n");
        return unique_ptr<AbsSeat>(new HuaWeiSeat);
    }

    unique_ptr<AbsTire> createTire()
    {
        printf("create Huawei Tire.\n");
        return unique_ptr<AbsTire>(new HuaWeiTire);
    }
};


/**
 * @brief The HuaWeiFactoy class                宝马汽车工厂
 */
class BMWFactoy : public AbsFactory
{
public:
    BMWFactoy()
    {

    }
    ~BMWFactoy()
    {
        printf("~BMWFactoy.\n");
    }

    unique_ptr<AbsSeat> createSeat()
    {
        printf("create BMW Seat.\n");
        return unique_ptr<AbsSeat>(new BMWSeat);
    }

    unique_ptr<AbsTire> createTire()
    {
        printf("create BMW Tire.\n");
        return unique_ptr<AbsTire>(new BMWTire);
    }
};



#include "SimpleFactory.h"


int main(int argc, char *argv[])
{
         std::unique_ptr<AbsFactory> ptr;
    std::unique_ptr<AbsSeat> ptrSeat;
    std::unique_ptr<AbsTire> ptrTire;

    ptr = std::unique_ptr<AbsFactory>(new HuaWeiFactoy);
    ptrSeat = ptr->createSeat();
    ptrSeat->show();
    ptrSeat->print();

    ptrTire = ptr->createTire();
    ptrTire->print();
    ptrTire->repair();

    // 转交指针管理
    ptr.reset();
    ptrSeat.reset();
    ptrTire.reset();

    printf("\n");

    ptr = std::unique_ptr<AbsFactory>(new BMWFactoy);
    ptrSeat = ptr->createSeat();
    ptrSeat->show();
    ptrSeat->print();

    ptrTire = ptr->createTire();
    ptrTire->print();
    ptrTire->repair();
    
    return 0;
    
}

 

3. 单例模式

单例模式意味着在整个程序中只有一个对象，并且这个对象的内存不会销毁，只有当程序退出之后才能回收(前提是要做好内存回收)

#ifndef __SINGLETON_H__
#define __SINGLETON_H__

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

class Singleton_Lazy
{
public:
    static Singleton_Lazy* getInstance(){
        printf("This is Singleton Lazy mode...\n");
        if (instance == NULL){
            m_mutex.lock();
            if (instance == NULL){
                printf("创建新的实例\n");
                instance = new Singleton_Lazy();
            }
            m_mutex.unlock();
        }
        return instance;
    }
private:
    Singleton_Lazy(){}

    static Singleton_Lazy* instance;
    static std::mutex m_mutex;
};

Singleton_Lazy* Singleton_Lazy::instance = NULL;
std::mutex Singleton_Lazy::m_mutex;


class Singleton_Hungry
{
public:
    static Singleton_Hungry* getInstance() 
    {
        printf("This Singleton Hungry mode...\n");
        return instance;
    }
private:
    Singleton_Hungry() {}
    static Singleton_Hungry* instance;
};

Singleton_Hungry* Singleton_Hungry::instance = new Singleton_Hungry;

#endif //__SINGLETON_H__



#include <iostream>
#include "Singleton.h"
#include<pthread.h>
#define THREAD_NUM 6

void* callSingleton_Lazy(void*)
{
    Singleton_Lazy *s = Singleton_Lazy::getInstance();
    pthread_t nThreadNum = pthread_self();
    // sleep(50);
    printf("线程编号为%lu\n", nThreadNum);
    return 0;
}

void* callSingleton_Hungry(void*)
{
    Singleton_Hungry *s = Singleton_Hungry::getInstance();
    pthread_t nThreadNum = pthread_self();
    // sleep(50);
    printf("线程编号为%ld\n", nThreadNum);
    return 0;
}

int main()
{
    pthread_t threads_pool[THREAD_NUM];
    int tids[THREAD_NUM], i;
    void* status;
    pthread_attr_t attr;

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    for(i = 0; i < THREAD_NUM; i++) 
    {
        if(i < THREAD_NUM / 2)
            tids[i] = pthread_create(&threads_pool[i], NULL, callSingleton_Lazy, (void*)&i);
        else 
            tids[i] = pthread_create(&threads_pool[i], NULL, callSingleton_Hungry, (void*)&i);
        if(tids[i]) 
        {
            printf("Error: unable to create thread.\n");
            exit(-1);
        }
    }

    pthread_attr_destroy(&attr);
    for(i = 0; i < THREAD_NUM; i++) 
    {
        tids[i] = pthread_join(threads_pool[i], &status);
        if(tids[i])
        {
            printf("Error: unable to join.\n");
            exit(-1);
        }
    }
    printf("main exiting.\n");
    return 0;
}

4. 建造者模式

建造者模式将客户端与包含多个部件的复杂对象的创建过程分离，客户端不必知道复杂对象的内部组成方式与装配方式（就好像Jungle不知道到底是如何把大象装进冰箱一样），只需知道所需建造者的类型即可。

“**同样的构建过程可以创建不同的表示**”？？也就是说建造一栋房子，建造过程无非都是打地基、筑墙、安装门窗等过程，但不同的客户可能希望不同的风格或者过程，最终建造出来的房子当然就呈现不同的风格

#pragma once

#include <iostream>
#include <string>
#include <memory>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

using namespace std;

#define     BUILDER_PATTERN_MODE        0

// 产品
class Product
{
public:
    Product(){}

    void setFloor(const string &str)
    {
        m_floor = str;
    }

    void setWall(const string &str)
    {
        m_wall = str;
    }

    void setLight(const string &str)
    {
        m_light = str;
    }

    void printInfo()
    {
        printf("floor: %s\n", m_floor.data());
        printf("wall: %s\n", m_wall.data());
        printf("light: %s\n", m_light.data());
    }

private:
    string m_floor;
    string m_wall;
    string m_light;
};


//建造者基类
class AbsBuilder
{
public:
    AbsBuilder()
    {

    }
    virtual ~AbsBuilder()
    {
        printf("~AbsBuilder.\n");
    }

    //禁止拷贝复制
    AbsBuilder(const AbsBuilder &abs) = delete ;
    AbsBuilder &operator=(const AbsBuilder &abs) = delete;

    virtual void buildFloor() = 0;
    virtual void buildWall() = 0;
    virtual void buildLight() = 0;
    virtual unique_ptr<Product> getPtr() = 0;

protected:
    unique_ptr<Product> ptr;
};


// 详细建造者A
class BuilderA : public AbsBuilder
{
public:
    BuilderA()
    {
        printf("BuildA.\n");
        this->ptr = unique_ptr<Product>(new Product);
    }
    ~BuilderA()
    {
        printf("~BuildA.\n");
    }

    void buildFloor() override
    {
        this->ptr->setFloor(string("Floor_A"));
    }

    void buildWall() override
    {
        this->ptr->setWall(string("Wall_A"));
    }

    void buildLight() override
    {
        this->ptr->setLight(string("Light_A"));
    }

    unique_ptr<Product> getPtr() override
    {
        // 直接返回有效地址
        return std::move(this->ptr);
    }

};



// 详细建造者B
class BuilderB : public AbsBuilder
{
public:
    BuilderB()
    {
        printf("BuildB.\n");
        this->ptr = unique_ptr<Product>(new Product);
    }
    ~BuilderB()
    {
        printf("~BuildB.\n");
    }

    void buildFloor() override
    {
        this->ptr->setFloor(string("Floor_B"));
    }

    void buildWall() override
    {
        this->ptr->setWall(string("Wall_B"));
    }

    void buildLight() override
    {
        this->ptr->setLight(string("Light_B"));
    }

    unique_ptr<Product> getPtr() override
    {
        // 直接返回有效地址
        return std::move(this->ptr);
    }

};


class Director
{
public:
    Director(){}

    // 禁止拷贝复制
    Director(const Director &obj) = delete;
    Director &operator=(const Director &obj) = delete;

    void setBuilder(unique_ptr<AbsBuilder> ptr)
    {
        absBuildPtr.reset(ptr.release());
    }

    unique_ptr<Product> construct()
    {
        absBuildPtr->buildWall();
        absBuildPtr->buildFloor();
        absBuildPtr->buildLight();
        return absBuildPtr->getPtr();
    }

private:
    unique_ptr<AbsBuilder> absBuildPtr;
};



#include "BuilderPattern.h"

int main(int argc, char *argv[])
{
    (void)argc;
    (void)argv;
    
    unique_ptr<Director> directorPtr(new Director);
    unique_ptr<AbsBuilder> absBuild(new BuilderA);

    directorPtr->setBuilder(std::move(absBuild));
    directorPtr->construct()->printInfo();

    printf("========\n\n");

    // 销毁指针A的内存，保留智能指针对象
    absBuild.reset(new BuilderB);
    directorPtr->setBuilder(std::move(absBuild));           // std::move移动拷贝赋值对象
    directorPtr->construct()->printInfo();


    return 0;    
}

 

以上是以前项目中用到的模式，后面如果再有使用的其他模式，同时也会做更新