C++/MFC 面试题（四、设计模式）

最新推荐文章于 2023-06-14 13:06:23 发布

LyRics1996

最新推荐文章于 2023-06-14 13:06:23 发布

阅读量924

点赞数

文章标签： c++ mfc 面试设计模式

本文链接：https://blog.csdn.net/LyRics1996/article/details/120456612

版权

C++ 同时被 3 个专栏收录

85 篇文章 42 订阅

订阅专栏

面试

6 篇文章 2 订阅

订阅专栏

设计模式

3 篇文章 0 订阅

订阅专栏

一、介绍

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

二、种类

设计模式的种类

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

23种设计模式C++实现

本章只简单的谈一下三种常用的设计模式：单例模式、工厂模式、适配器模式

三、单例模式

单例模式是最简单的设计模式之一，其作用就是为了保证全局只有一个实例对象。

3.1 三点注意：

单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。

3.2 实现方式：

懒汉式：线程不安全

  class singleton   //实现单例模式的类  
  {  
  private:  
      singleton(){}  //私有的构造函数  
      static singleton* Instance;  
  public:  
      static singleton* GetInstance()  
      {  
          if (Instance == NULL) //判断是否第一调用  
              Instance = new singleton();  
          return Instance;  
      }  
  };

这种写法，就是调用GetInstance时才会被new，所以在多线程情况下，如果两个线程同时首次调用GetInstance方法且同时检测到Instance是NULL，则两个线程会同时构造一个实例给Instance，这样就会发生错误。

懒汉改进版（加锁）

 class singleton   //实现单例模式的类  
  {  
  private:  
      singleton(){}  //私有的构造函数  
      static singleton* Instance;  
        
  public:  
      static singleton* GetInstance()  
      {  
          if (Instance == NULL) //判断是否第一调用  
          {   
              Lock(); //表示上锁的函数  
              if (Instance == NULL)  
              {  
                  Instance = new singleton();  
              }  
              UnLock() //解锁函数  
          }             
          return Instance;  
      }  
  };

饿汉模式

class singleton   //实现单例模式的类  
{
private:
	singleton() {}  //私有的构造函数  

public:
	static singleton* GetInstance()
	{
		static singleton Instance;
		return &Instance;
	}
};

饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。饿汉模式是线程安全的。

四、工厂模式

工厂模式（Factory Pattern）是最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

4.1 简单工厂模式

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

四个类：
car类：抽象类，
BenzCar 和BmwCar 都继承自car，实现car的方法
工厂类：CarFactory ，将奔驰、宝马等各种车的类通过switch来返回
在这里插入图片描述

#include <iostream>
using namespace std;

enum CarType{BENZ, BMW};

class Car//车类
{
public:
    virtual void createdCar(void) = 0;
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BenzCar::createdCar()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BmwCar::createdCar()"<<endl;
    }
};


class CarFactory //车厂
{
public:
    Car* createSpecificCar(CarType type)
    {
        switch(type)
        {
        case BENZ://生产奔驰车
            return (new BenzCar());
            break;
        case BMW://生辰宝马车
            return (new BmwCar());
            break;
        default:
            return NULL;
            break;
        }
    }
};

int main(int argc, char** argv)
{
    CarFactory carfac;
    Car* specificCarA = carfac.createSpecificCar(BENZ);
    Car* specificCarB = carfac.createSpecificCar(BMW);
    delete specificCarA; delete specificCarB;
    return 0;
}

简单工厂模式在每次增加新的车型时，需要修改工厂类，这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。

4.2 工厂方法模式

工厂方法模式：不再只由一个工厂类决定那一个产品类应当被实例化,这个决定权被交给子类去做。当有新的产品（新型汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的方法来生成即可（新车型可以用一个新类继承创建产品即可），那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则。

看代码，我们发现，其实是将一个工厂类变为了一个抽象的工厂，并且不同的车写不同的工厂类继承抽象工厂。

#include <iostream>
using namespace std;

class Car//车类
{
public:
    virtual void createdCar(void) = 0;
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BenzCar::createdCar()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BmwCar::createdCar()"<<endl;
    }
};


class Factory//车厂
{
public:
    virtual Car* createSpecificCar(void) = 0;
};

class BenzFactory : public Factory//奔驰车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BenzCar());
    }
};

class BmwFactory : public Factory//宝马车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BmwCar());
    }
};


int main(int argc, char** argv)
{
    Factory* factory = new BenzFactory();
    Car* specificCarA = factory->createSpecificCar();
    factory = new BmwFactory();
    Car* specificCarB = factory->createSpecificCar();
    
    delete factory; delete specificCarA; delete specificCarB;
    
    return 0;
}

4.3 抽象工厂模式

上面的工厂只能生成特定要求的产品，或者说，只能生成一类产品，要生成其他的产品。就不行了
其实区别就是在抽象的工厂类里增加一个新的方法（新的产品线），新的产品类即可。

#include <iostream>
using namespace std;

class Car//车类
{
public:
    virtual void createdCar(void) = 0;
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BenzCar::createdCar()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BmwCar::createdCar()"<<endl;
    }
};

class HighCar //高配版车型
{
public:
    virtual void createdCar(void) = 0;
};

class HighBenzCar : public HighCar //高配奔驰车
{
public:
    HighBenzCar()
    {
        cout<<"HighBenzCarBenz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"HighBenzCar::createdCar()"<<endl;
    }
};

class HighBmwCar : public HighCar //高配宝马车
{
public:
    HighBmwCar()
    {
        cout<<"HighBmwCar::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"HighBmwCar::createdCar()"<<endl;
    }
};

class Factory//车厂
{
public:
    virtual Car* createSpecificCar(void) = 0;
    virtual HighCar* createdSpecificHighCar(void) = 0;
};

class BenzFactory : public Factory//奔驰车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BenzCar());
    }

    virtual HighCar* createdSpecificHighCar(void)
    {
        return (new HighBenzCar());
    }
};

class BmwFactory : public Factory//宝马车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BmwCar());
    }
    virtual HighCar* createdSpecificHighCar(void)
    {
        return (new HighBmwCar());
    }
};


int main(int argc, char** argv)
{
    Factory* factory = new BenzFactory();
    Car* specificCar = factory->createSpecificCar();
    HighCar* spcificHighCar = factory->createdSpecificHighCar();
    
    delete factory; delete specificCar; delete spcificHighCar;
    
    return 0;
}

五、适配器模式

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

5.1 优缺点

优点：

可以让任何两个没有关联的类一起运行。
提高了类的复用。
增加了类的透明度。
灵活性好。

缺点：

过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。
由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。

5.2 举例：

举例：假设你们公司有最近收购了一家公司，两家公司都有各自的人员管理系统，两个系统都可以获取每一个员工的姓名。
你们公司系统中接口是：getName（）；
被收购公司系统中接口是：etPeopleName（）；
现在领导要求用我们公司的系统也可以查看新收购公司的人员信息。单很明显二者接口不一样啊。此时适配器模式就有用了。

#include <iostream>
#include <string>

using namespace std;

/*****原系统A：Target*****/
class MangeSystemA
{
public:
    virtual void getName()
    {
        cout << "获取系统A中员工的名称" << endl;
    }
};

/*****要集成的系统B：Adaptee*****/
class MangeSystemB
{
public:
    virtual void getPeopleName()
    {
        cout << "获取系统B中员工的名称" << endl;
    }
};


/***适配器：Adapter***/
class AdapterSystem : public MangeSystemA
{
public:
    AdapterSystem(MangeSystemB *pSysB) :m_pSysB(pSysB){}
    virtual void getName()
    {
        m_pSysB->getPeopleName();
    }
private:
    MangeSystemB *m_pSysB;
};

/****系统A工作场景****/
int main()
{

    MangeSystemB *sysB = new MangeSystemB;
    //创建适配器
    MangeSystemA *sysA = new AdapterSystem(sysB);
    sysA->getName();

    return 0;
}
结果：
获取系统B中员工的名称
请按任意键继续. . .

说白了，就是老的类A要合入新的类B，新的类B的方法和老的类A不一样，而老的类A正好是继承自虚类Base，那么我们就写一个类继承自Base，这个类的目的就是实现Base 的方法，将B包装进去，从而获取B的功能。

LyRics1996

关注

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
C++/MFC 面试题（四、设计模式）

一、介绍设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。二、种类设计模式的种类创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模
复制链接

扫一扫