C++实现面试常见设计模式(未完待续)

单例模式

1.懒汉模式

GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。这是一种防弹设计——所有GetInstance()之后的调用都返回相同实例的指针。

class CSingleton{
public:
    static CSingleton* GetInstance(){
        if (m_pInstance == nullptr)
            m_pInstance = new CSingleton();
        return m_pInstance;
    }
    ~CSingleton(){};
private:
    CSingleton(){};
    Singleton(Singleton)=delete;//?????
    Singleton operator=(const Singleton)=delete;//?????
    static CSingleton* m_pInstance;
}
Singleton* Singleton::m_instance_ptr = nullptr;

线程安全的懒汉模式：

class Singleton{
public:
    typedef std::shared_ptr<Singleton> Ptr;
    ~Singleton(){
        std::cout<<"destructor called!"<<std::endl;
    }
    Singleton(Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    static Ptr get_instance(){

        // double checked lock
        if(m_instance_ptr==nullptr){
            std::lock_guard<std::mutex> lk(m_mutex);
            if(m_instance_ptr == nullptr){
              m_instance_ptr = std::shared_ptr<Singleton>(new Singleton);
            }
        }
        return m_instance_ptr;
    }


private:
    Singleton(){
        std::cout<<"constructor called!"<<std::endl;
    }
    static Ptr m_instance_ptr;
    static std::mutex m_mutex;
};

2.饿汉模式

class CSingleton{
private:
    CSingleton(){}
pubic:
    static CSingleton* GetInstance(){
        static CSingleton* instance;
        return instance;
    }
}

多线程模式下会出问题的，线程安全的饿汉模式如下：

class CSingleton  
{  
private:  
    static CSingleton* m_instance;  
    CSingleton(){}  
public:  
    static CSingleton* getInstance();  
};  

CSingleton* CSingleton::getInstance()  
{  
    if(NULL == m_instance)  
    {  
        Lock();//借用其它类来实现，如boost  
        if(NULL == m_instance)  
        {  
            m_instance = new Singleton;  
        }  
        UnLock();  
    }  
    return m_instance;  
}

3.Magic Static

#include <iostream>

class Singleton
{
public:
    ~Singleton(){
        std::cout<<"destructor called!"<<std::endl;
    }
    Singleton(const Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    static Singleton& get_instance(){
        static Singleton instance;
        return instance;

    }
private:
    Singleton(){
        std::cout<<"constructor called!"<<std::endl;
    }
};

这种方法又叫做 Meyers' SingletonMeyer's的单例， 是著名的写出《Effective C++》系列书籍的作者 Meyers 提出的。所用到的特性是在C++11标准中的Magic Static特性：

If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.
如果当变量在初始化的时候，并发同时进入声明语句，并发线程将会阻塞等待初始化结束。
请在这里输入引用内容
这样保证了并发线程在获取静态局部变量的时候一定是初始化过的，所以具有线程安全性。

C++静态变量的生存期 是从声明到程序结束，这也是一种懒汉式。

这是最推荐的一种单例实现方式：

通过局部静态变量的特性保证了线程安全 (C++11, GCC > 4.3, VS2015支持该特性);
不需要使用共享指针，代码简洁；
注意在使用的时候需要声明单例的引用 Single& 才能获取对象。

观察者模式

Subject（目标）

  • 目标知道它的观察者。可以有任意多个观察者观察同一个目标；
  • 提供注册和删除观察者对象的接口。

Observer（观察者）

  • 为那些在目标发生改变时需获得通知的对象定义一个更新接口。

ConcreteSubject（具体目标）

  • 将有关状态存入各ConcreteObserver对象；
  • 当它的状态发生改变时，向它的各个观察者发出通知。

ConcreteObserver（具体观察者）

  • 维护一个指向ConcreteSubject对象的引用；
  • 存储有关状态，这些状态应与目标的状态保持一致；
  • 实现Observer的更新接口以使自身状态与目标的状态保持一致。

https://www.cnblogs.com/carsonzhu/p/5770253.html

工厂模式

工厂模式包括三种：简单工厂模式、工厂方法模式、抽象工厂模式。

工厂模式的主要作用是封装对象的创建，分离对象的创建和操作过程，用于批量管理对象的创建过程，便于程序的维护和扩展。

1.简单工厂模式

简单工厂是工厂模式最简单的一种实现，对于不同产品的创建定义一个工厂类，将产品的类型作为参数传入到工厂的创建函数，根据类型分支选择不同的产品构造函数。

//简单工厂模式
typedef enum ProductTypeTag
{
    TypeA,
    TypeB,
    TypeC
}PRODUCTTYPE;

class Product//产品抽象基类
{
public:
    virtual void Show() = 0;
};

class ProductA : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductA"<<endl;
    }
};

class ProductB : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductB"<<endl;
    }
};

class ProductC : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductC"<<endl;
    }
};

class Factory//工厂类
{
public:
    Product* CreateProduct(PRODUCTTYPE type)
    {
        switch (type)
        {
        case TypeA:
            return new ProductA();
        case TypeB:
            return new ProductB();
        case TypeC:
            return new ProductC();
        default:
            return NULL;
        }
    }
};

int main()
{
    Factory productCreator;
    Product *productA=productCreator.CreateProduct(TypeA);
    Product *productB=productCreator.CreateProduct(TypeB);
    Product *productC=productCreator.CreateProduct(TypeC);
    productA->Show();
    productB->Show();
    productC->Show();
    if(productA){
        delete productA;
        productA=NULL;
    }
    if(productB){
        delete productB;
        productB=NULL;
    }
    if(productC){
        delete productC;
        productC=NULL;
    }
    return 0;
}

2.工厂方法模式

其实这才是正宗的工厂模式，简单工厂模式只是一个简单的对创建过程封装。工厂方法模式在简单工厂模式的基础上增加对工厂的基类抽象，不同的产品创建采用不同的工厂创建（从工厂的抽象基类派生），这样创建不同的产品过程就由不同的工厂分工解决：FactoryA专心负责生产ProductA，FactoryB专心负责生产ProductB，FactoryA和FactoryB之间没有关系；如果到了后期，如果需要生产ProductC时，我们则可以创建一个FactoryC工厂类，该类专心负责生产ProductC类产品。

该模式相对于简单工厂模式的优势在于：便于后期产品种类的扩展。

//工厂方法模式
typedef enum ProductTypeTag
{
    TypeA,
    TypeB,
    TypeC
}PRODUCTTYPE;

class Product//产品抽象基类
{
public:
    virtual void Show() = 0;
};

class ProductA : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductA"<<endl;
    }
};

class ProductB : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductB"<<endl;
    }
};

class Factory//工厂类
{
public:
    virtual Product *createProduct()=0;
};

class FactoryA:public Factory{
public:
    Product *createProduct(){
        return new ProductA();
    }
};

class FactoryB:public Factory{
public:
    Product *createProduct(){
        return new ProductB();
    }
};

class FactoryC:public Factory{
public:
    Product *createProduct(){
        return new ProductC();
    }
};

int main()
{
    Factory *factoryA=new FactoryA();
    Product *productA = factoryA->createProduct();
    productA->Show();
    Factory *factoryB=new FactoryB();
    Product *productB = factoryB->createProduct();
    productB->Show();
    if (factoryA)
    {
        delete factoryA;
        factoryA = NULL;
    }
    if (factoryB)
    {
        delete factoryB;
        factoryB = NULL;
    }
    if (productA)
    {
        delete productA;
        productA = NULL;
    }
    if (productB)
    {
        delete productB;
        productB = NULL;
    }
    return 0;
}

3.抽象工厂模式

抽象工厂模式对工厂方法模式进行了更加一般化的描述。工厂方法模式适用于产品种类结构单一的场合，为一类产品提供创建的接口；而抽象工厂方法适用于产品种类结构多的场合，就是当具有多个抽象产品类型时，抽象工厂便可以派上用场。

抽象工厂模式更适合实际情况，受生产线所限，让低端工厂生产不同种类的低端产品，高端工厂生产不同种类的高端产品。

//抽象工厂模式
class ProductA
{
public:
    virtual void Show() = 0;
};

class ProductA1 : public ProductA//A类低端产品
{
public:
    void Show()
    {
        cout<<"I'm ProductA1"<<endl;
    }
};

class ProductA2 : public ProductA//A类高端产品
{
public:
    void Show()
    {
        cout<<"I'm ProductA2"<<endl;
    }
};

class ProductB
{
public:
    virtual void Show() = 0;
};

class ProductB1 : public ProductB//B类低端产品
{
public:
    void Show()
    {
        cout<<"I'm ProductB1"<<endl;
    }
};

class ProductB2 : public ProductB//B类高端产品
{
public:
    void Show()
    {
        cout<<"I'm ProductB2"<<endl;
    }
};

class Factory
{
public:
    virtual ProductA *CreateProductA() = 0;
    virtual ProductB *CreateProductB() = 0;
};

class Factory1 : public Factory//1号工厂用于生产低端产品
{
public:
    ProductA *CreateProductA()
    {
        return new ProductA1();
    }
    ProductB *CreateProductB()
    {
        return new ProductB1();
    }
};

class Factory2 : public Factory//2号工厂用于生产高端产品
{
    ProductA *CreateProductA()
    {
        return new ProductA2();
    }
    ProductB *CreateProductB()
    {
        return new ProductB2();
    }
};

int main()
{
    Factory *factory1 = new Factory1();
    ProductA *productA1 = factory1->CreateProductA();
    ProductB *productB1 = factory1->CreateProductB();
    productA1->Show();
    productB1->Show();
    Factory *factory2 = new Factory2();
    ProductA *productA2 = factory2->CreateProductA();
    ProductB *productB2 = factory2->CreateProductB();
    productA2->Show();
    productB2->Show();
    if (factory1)
    {
        delete factory1;
        factory1 = NULL;
    }
    if (productA1)
    {
        delete productA1;
        productA1= NULL;
    }
    if (productB1)
    {
        delete productB1;
        productB1 = NULL;
    }
    if (factory2)
    {
        delete factory2;
        factory2 = NULL;
    }
    if (productA2)
    {
        delete productA2;
        productA2 = NULL;
    }
    if (productB2)
    {
        delete productB2;
        productB2 = NULL;
    }
}
全部评论

相关推荐

头像
carpe_dime
05-20 21:53
已编辑
门头沟学院 电子信息类
offer选择求助
本人26届末流985硕，研一下，目前有两个日常实习的offer的选择，mmt感知算法岗实习和百度智能驾驶技术部感知算法岗实习，实习内容相差不大，工作强度也差不多。现在陷入了选择纠结中，mmt的offer拿的更早，base苏州，实习薪资待遇可观。百度的offer面试周期太长了（一面结束后一个星期才收到二面通知，还在约面中），base北京，实习薪资较低，基本上收支平衡，生活压力较大。目前纠结的是百度的自驾岗背书能力好像更强一些，但是地处北京，工资不高。（其实内心还是想去苏州的mmt，可是放不下百度的背书能力）想问问大家以后想从事自驾算法岗，mmt和百度的背书能力相差...
投递百度等公司10个岗位 > 实习必须要去大厂吗？
点赞 评论 收藏
转发
头像
卷山羊
05-16 17:49
门头沟学院 计算机类
点赞 评论 收藏
转发
头像
万木春寒江雪
04-13 15:09
南京邮电大学 电子信息类
点赞 评论 收藏
转发
头像
牛客330273880号
昨天 10:49
上海大学 电气类
点赞 评论 收藏
转发
头像
niuniuniuniuniuniuniuniu
05-16 12:39
人工智能
点赞 评论 收藏
转发
1 4 评论
分享

全站热榜

正在热议
# 牛客帮帮团来啦！有问必答 #
821047次浏览 13029人参与
# 机械制造薪资爆料 #
319917次浏览 3732人参与
# 晒一晒我的offer #
3465989次浏览 55257人参与
# 0offer是寒冬太冷还是我太菜 #
427813次浏览 4942人参与
# 你觉得找工作该拿大厂还是小厂练手 #
61580次浏览 872人参与
# 荣耀求职进展汇总 #
70589次浏览 717人参与
# 如果可以选，你最想从事什么工作 #
185981次浏览 3077人参与
# 实习生应该准时下班吗 #
80728次浏览 592人参与
# 金三银四，你有感觉到吗 #
329037次浏览 4220人参与
# 海康威视求职进展汇总 #
101569次浏览 1216人参与
# 正在春招的你，也参与了去年秋招吗？ #
136431次浏览 1705人参与
# 实习必须要去大厂吗？ #
13824次浏览 219人参与
# 实习工作，你找得还顺利吗？ #
42383次浏览 469人参与
# 我在牛爱网找对象 #
49750次浏览 321人参与
# 软件开发投递记录 #
479061次浏览 7242人参与
# 宁德时代求职进展汇总 #
37036次浏览 413人参与
# 国企vs私企，你更想去？ #
20264次浏览 205人参与
# 求职遇到的搞笑事件 #
19665次浏览 287人参与
# 想实习转正，又想准备秋招，我该怎么办 #
117780次浏览 1328人参与
# 正在实习的你，有转正机会吗？ #
106389次浏览 1043人参与
牛客网
牛客企业服务