C++单例模式、工厂模式

已于 2024-06-28 16:35:27 修改
阅读量1.2k 收藏 25
点赞数 26
文章标签： c++ 单例模式 简单工厂模式 抽象工厂模式 工厂方法模式
于 2024-03-06 18:36:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75034791/article/details/136513937
版权

一、单例模式

(一) 什么是单例模式
1. 是什么？

在系统的整个生命周期内，一个类只允许存在一个实例。

2. 为什么？

两个原因：

  • 节省资源。
  • 方便控制，在操作公共资源的场景时，避免了多个对象引起的复杂操作。
3. 线程安全

在单例模式的实现时，需要考虑线程安全问题。

什么是线程安全？

  • 多线程并行执行共享数据，线程安全的代码是可以通过同步机制来保证各个线程正常且正确地执行，不会产生数据的污染。

如何保证线程安全？

  • 加锁，保证资源每时每刻只被一个线程占用。
  • 让线程拥有资源，不用去共享。如：threadlocal可以为每一个线程维护一个私有的本地变量。
4. 单例模式分类
  • 懒汉式

系统运行中，实例并不存在，只有当需要使用时，才去创建。需要考虑线程安全。

  • 饿汉式（未雨绸缪）

系统一运行，就初始化创建实例，当需要时，直接调用。这样是线程安全的。

5. 单例类的特点
  • 构造函数和析构函数都是私有，防止外部构造和析构
  • 拷贝构造和赋值构造都是私有，防止外部拷贝和赋值
  • 一个静态的获取实例的方法，可以全局访问
(二) 单例模式实现
1. 加锁的懒汉式单例（线程安全）
#include <mutex>
#include <iostream>

// 加锁的懒汉单例模式
class SingleInstance
{
public:
    // 获取实例
    static SingleInstance *getInstance();
    // 进程退出时，销毁实例
    static void deleteInstance();
    // 打印实例地址
    void printAddr() { std::cout << "实例的内存地址:" << this << "\n"; }

private:
    // 私有的构造和析构
    SingleInstance();
    ~SingleInstance();

    // 私有的拷贝构造和赋值构造，外部无法调用
    SingleInstance(const SingleInstance &singleInstance);
    const SingleInstance &operator=(const SingleInstance &singleInstance);

    // 对象指针和互斥锁
    static SingleInstance *singleInstance_;
    static std::mutex mutex_;
};
#include "sigleInstance.h"

SingleInstance *singleInstance_ = nullptr;
std::mutex mutex_;

// 获取实例
SingleInstance *SingleInstance::getInstance()
{   
    // 此处使用双检锁（两个if），只在指针为空的时候加锁，避免开销
    if(singleInstance_ == nullptr)
    {
        std::unique_lock<std::mutex> lock(mutex_);
        if(singleInstance_ == nullptr) // 同时检测有无其他线程已经创建了实例
        {
            volatile auto tmp = new (std::nothrow) SingleInstance();
            singleInstance_ = tmp;
        }
    }
    return singleInstance_;
}

// 进程退出时，销毁实例
void SingleInstance::deleteInstance()
{   
    std::unique_lock<std::mutex> lock(mutex_);  // 加锁
    if(singleInstance_)
    {
        delete singleInstance_;
        singleInstance_ = nullptr;
    }
}
2. 经典实现方法：“静态局部变量”+“懒汉单例”（C++11线程安全）
class Single
{
public:
    static Single &getInstance()
    {
        // 局部静态变量只在第一次使用的时候初始化
        Single single;
        retunr single;
    }

    void print();

private:
    Single();
    ~Single();

    // 禁止拷贝和赋值
    Single(const Single &single) = delete;
    Single &operator=(const Single &single) = delete;
};
3. 饿汉式单例（线程安全）
#include <iostream>
// 饿汉模式
HungrySingle *hungrySingle_ = new (std::nothrow) HungrySingle();

class HungrySingle
{
public:
    static HungrySingle *getInstance()
    {
        return hungrySingle_;
    }

    static deleteInstance()
    {
        if(hungrySingle_)
        {
            delete hungrySingle_;
            hungrySingle_ = nullptr;
        }
    }
    void print() {}

private:
    HungrySingle() {}
    ~HungrySingle() {}

    HungrySingle(const HungrySingle& hungrySingle);
    const HungrySingle &operator= (const HungrySingle &hungrySingle);

    static HungrySingle *hungrySingle_;
};
4. 使用std::call_once实现单例（C++11线程安全）
#include <iostream>
#include <memory>
#include <mutex>

class Singleton {
public:
    static std::shared_ptr<Singleton> getSingleton();

    void print() {}
    ~Singleton() {}

private:
    Singleton() {}
};

static std::shared_ptr<Singleton> singleton = nullptr;
static std::once_flag singletonFlag;

std::shared_ptr<Singleton> Singleton::getSingleton() {
    std::call_once(singletonFlag, [&] { singleton = std::shared_ptr<Singleton>(new Singleton()); });
    return singleton;
}

二、工厂模式

(一) 什么是工厂模式
1. 是什么、为什么？

工厂模式属于创建型模式，在创建对象的时候不会对客户端暴露创建逻辑，并且通过使用一个共同的接口来指向新创建的对像。将会利用到多态和继承。

2. 工厂模式分类
  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式
(二) 分析与实现
1. 简单工厂模式

哪个火爆就生产哪个（下面用鞋厂为例）。

核心组件：

  1. 工厂类：会定义一个用于创建指定的具体实例额接口。
  2. 抽象产品类：大类（如上图Shoes），用来继承。
  3. 具体产品类：工厂类创建的对象，具体的产品。

简单工厂模式的特点：

工厂类封装了创建具体产品对象的函数。

缺陷：

拓展性差，新增产品的时候，需要修改工厂。

代码实现：

// 鞋子抽象类
class Shoes
{
public:
    virtual ~Shoes() {}
    virtual void Show() = 0;
};

class NiKeShoes : public Shoes
{
public:
    void Show() {}
};

class AdidasShoes : public Shoes
{
public:
    void Show() {}
};

class LiNingShoes : public Shoes
{
public:
    void Show() {}
};
enum SHOES_TYPE
{
    NIKE,
    LINING,
    ADIDAS
};

// 总鞋厂
class ShoesFactory
{
public:
    // 根据鞋子类型创建对应的鞋子对象
    Shoes *CreateShoes(SHOES_TYPE type)
    {
        switch (type)
        {
        case NIKE:
            return new NiKeShoes();
            break;
        case LINING:
            return new LiNingShoes();
            break;
        case ADIDAS:
            return new AdidasShoes();
            break;
        default:
            return NULL;
            break;
        }
    }
};

在main函数调用时：

int main()
{
    // 构造工厂对象
    ShoesFactory shoesFactory;

    Shoes *pNikeShoes = shoesFactory.CreateShoes(NIKE);
    if (pNikeShoes != NULL)
    {
        // 耐克球鞋广告
        pNikeShoes->Show();
        // 释放资源
        delete pNikeShoes;
        pNikeShoes = NULL;
    }

    Shoes *pLiNingShoes = shoesFactory.CreateShoes(LINING);
    if (pLiNingShoes != NULL)
    {
        // 李宁球鞋广告
        pLiNingShoes->Show();
        // 释放资源
        delete pLiNingShoes;
        pLiNingShoes = NULL;
    }

    Shoes *pAdidasShoes = shoesFactory.CreateShoes(ADIDAS);
    if (pAdidasShoes != NULL)
    {
        // 阿迪达斯球鞋广告
        pAdidasShoes->Show();
        // 释放资源
        delete pAdidasShoes;
        pAdidasShoes = NULL;
    }
    return 0;
}
2. 工厂方法模式

每种产品都有独立的生产线

核心组件：

  1. 抽象工厂类：用于继承的“大类”。
  2. 具体工厂类：继承于抽象工厂，实现创建对应具体产品对象的方法。
  3. 抽象产品类：用于继承的“大类”。
  4. 具体产品类：具体工厂创建的具体产品对象。

工厂方法模式的特点：

  • 抽象的工厂类（“大类”）。

工厂方法模式的缺陷：

  • 每多一个产品，就需要增加一个具体工厂（“生产线”），相比简单工厂模式，需要定义更多类。
  • 一个工厂只能生产一种产品。

工厂方法模式的代码：

// 总鞋厂
class ShoesFactory
{
public:
    virtual Shoes *CreateShoes() = 0;
    virtual ~ShoesFactory() {}
};

// 耐克生产者/生产链
class NiKeProducer : public ShoesFactory
{
public:
    Shoes *CreateShoes() { return new NiKeShoes(); }
};

// 阿迪达斯生产者/生产链
class AdidasProducer : public ShoesFactory
{
public:
    Shoes *CreateShoes() { return new AdidasShoes(); }
};

// 李宁生产者/生产链
class LiNingProducer : public ShoesFactory
{
public:
    Shoes *CreateShoes() { return new LiNingShoes(); }
};

main函数执行：

int main()
{
    // 鞋厂开设耐克生产线
    ShoesFactory *niKeProducer = new NiKeProducer();
    // 耐克生产线产出球鞋
    Shoes *nikeShoes = niKeProducer->CreateShoes();
    // 耐克球鞋广告
    nikeShoes->Show();
    // 释放资源
    delete nikeShoes;
    delete niKeProducer;

    // 鞋厂开设阿迪达斯生产者
    ShoesFactory *adidasProducer = new AdidasProducer();
    // 阿迪达斯生产线产出球鞋
    Shoes *adidasShoes = adidasProducer->CreateShoes();
    // 阿迪达斯球鞋广告
    adidasShoes->Show();
    // 释放资源
    delete adidasShoes;
    delete adidasProducer;

    return 0;
}
3. 抽象工厂模式

产品不止一类，比如上面提到的鞋厂也要生产运动服。

核心组件：和工厂方法模式一样

抽象工厂模式的特点：

  • 一个接口，可以创建多个产品族中的产品对象。如上图，耐克工厂->耐克衣服、耐克鞋子。

抽象工厂模式的缺陷：和工厂方法模式一样，新增产品必须添加具体工厂类

抽象工厂模式代码：

// 基类 衣服
class Clothe
{
public:
    virtual void Show() = 0;
    virtual ~Clothe() {}
};

// 耐克衣服
class NiKeClothe : public Clothe
{
public:
    void Show() {}
};

// 基类 鞋子
class Shoes
{
public:
    virtual void Show() = 0;
    virtual ~Shoes() {}
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
    void Show() {}
};
// 总厂
class Factory
{
public:
    virtual Shoes *CreateShoes() = 0;
	virtual Clothe *CreateClothe() = 0;
    virtual ~Factory() {}
};

// 耐克生产者/生产链
class NiKeProducer : public Factory
{
public:
    Shoes *CreateShoes() { return new NiKeShoes(); }
	
	Clothe *CreateClothe() { return new NiKeClothe(); }
};

main函数执行：

int main()
{
    // 鞋厂开设耐克生产线
    Factory *niKeProducer = new NiKeProducer();

    // 耐克生产线产出球鞋
    Shoes *nikeShoes = niKeProducer->CreateShoes();
    // 耐克生产线产出衣服
    Clothe *nikeClothe = niKeProducer->CreateClothe();

    // 耐克球鞋广告
    nikeShoes->Show();
    // 耐克衣服广告
    nikeClothe->Show();

    // 释放资源
    delete nikeShoes;
    delete nikeClothe;
    delete niKeProducer;

    return 0;
}
(三) 封装性更好的工厂模式
1. 模板工厂

对于工厂方法模式，模板编程，把工厂类改为模板工厂类。

模板工厂模式代码：

产品类：

// 基类 鞋子
class Shoes
{
public:
virtual void Show() = 0;
virtual ~Shoes() {}
};

// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
void Show() {}
};

// 基类 衣服
class Clothe
{
public:
virtual void Show() = 0;
virtual ~Clothe() {}
};

// 优衣库衣服
class UniqloClothe : public Clothe
{
public:
void Show() {}
};

模板的工厂类：

// 抽象模板工厂类
// 模板参数：AbstractProduct_t 产品抽象类
template <class AbstractProduct_t>
class AbstractFactory
{
public:
    virtual AbstractProduct_t *CreateProduct() = 0;
    virtual ~AbstractFactory() {}
};

// 具体模板工厂类
// 模板参数：AbstractProduct_t 产品抽象类，ConcreteProduct_t 产品具体类
template <class AbstractProduct_t, class ConcreteProduct_t>
class ConcreteFactory : public AbstractFactory<AbstractProduct_t>
{
public:
    AbstractProduct_t *CreateProduct()
    {
        return new ConcreteProduct_t();
    }
};
2. 产品注册模板类 + 单例工厂模板类

在模板工厂中，对工厂类进行了模板编程的封装。不过，对于产品类，还是缺少一个可以统一随时随地获取指定产品对对象的类。

对此，我们可以把产品注册的对象用map保存起来。

// 基类，产品注册模板接口类
// 模板参数 ProductType_t 表示的类是产品抽象类
template <class ProductType_t>
class IProductRegistrar
{
public:
   // 获取产品对象抽象接口
   virtual ProductType_t *CreateProduct() = 0;

protected:
   // 禁止外部构造和虚构, 子类的"内部"的其他函数可以调用
   IProductRegistrar() {}
   virtual ~IProductRegistrar() {}

private:
   // 禁止外部拷贝和赋值操作
   IProductRegistrar(const IProductRegistrar &);
   const IProductRegistrar &operator=(const IProductRegistrar &);
};

// 工厂模板类，用于获取和注册产品对象
// 模板参数 ProductType_t 表示的类是产品抽象类
template <class ProductType_t>
class ProductFactory
{
public:
   // 获取工厂单例，工厂的实例是唯一的
   static ProductFactory<ProductType_t> &Instance()
   {
      static ProductFactory<ProductType_t> instance;
      return instance;
   }

   // 产品注册
   void RegisterProduct(IProductRegistrar<ProductType_t> *registrar, std::string name)
   {
      m_ProductRegistry[name] = registrar;
   }

   // 根据名字name，获取对应具体的产品对象
   ProductType_t *GetProduct(std::string name)
   {
      // 从map找到已经注册过的产品，并返回产品对象
      if (m_ProductRegistry.find(name) != m_ProductRegistry.end())
      {
         return m_ProductRegistry[name]->CreateProduct();
      }

      // 未注册的产品，则报错未找到
      std::cout << "No product found for " << name << std::endl;

      return NULL;
   }

private:
   // 禁止外部构造和虚构
   ProductFactory() {}
   ~ProductFactory() {}

   // 禁止外部拷贝和赋值操作
   ProductFactory(const ProductFactory &);
   const ProductFactory &operator=(const ProductFactory &);

   // 保存注册过的产品，key:产品名字 , value:产品类型
   std::map<std::string, IProductRegistrar<ProductType_t> *> m_ProductRegistry;
};

// 产品注册模板类，用于创建具体产品和从工厂里注册产品
// 模板参数 ProductType_t 表示的类是产品抽象类（基类），ProductImpl_t 表示的类是具体产品（产品种类的子类）
template <class ProductType_t, class ProductImpl_t>
class ProductRegistrar : public IProductRegistrar<ProductType_t>
{
public:
   // 构造函数，用于注册产品到工厂，只能显示调用
   explicit ProductRegistrar(std::string name)
   {
      // 通过工厂单例把产品注册到工厂
      ProductFactory<ProductType_t>::Instance().RegisterProduct(this, name);
   }

   // 创建具体产品对象指针
   ProductType_t *CreateProduct()
   {
      return new ProductImpl_t();
   }
};

关键之处：

  1. 在产品注册模板接口类中，产品的构造和析构是protected权限，用于在模板工厂注册产品。
  2. 模板工厂中，有一个map<产品名字，产品类型>，记录注册的产品。
  3. 单独一个模板产品注册类，它的构造函数用于向map注册产品，只能显式调用。

声明

工厂模式的内容是从小林coding相关文章总结而来，UML图也是来自小林coding。C++ 深入浅出工厂模式（进阶篇）_"我是耐克球鞋,我的广告语:just do it\" 工厂模式"-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_34827674/article/details/100864623

WISHMELUCK1'
关注
  • 26
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
经典工厂单例模式典范
12-06
经典的学习典范，经典的学习实例，专供您学习当今最新的主流技术，希望您喜欢。
单例工厂
weixin_43831204的博客
11-22 359
public class SingletonFactory { @SuppressWarnings("rawtypes") private static Map<Class,Object> instaces = new ConcurrentHashMap<Class, Object>(); @SuppressWarnings("rawtypes") private sta...
c++ 单例模式
最新发布
weixin_45672157的博客
06-16 794
单例模式（SingletonPattern）是一种常用的程序设计模式，属于创建型设计模式的一种。它的核心思想在于控制类的实例化过程，确保在任何情况下，对于特定类来说，在整个应用程序中只存在一个实例，并提供一个全局访问点来获取这个实例。这样做可以确保共享资源的有效管理，减少系统开销，以及在需要全局访问和协调控制时提供便利。唯一性：确保一个类只有一个实例。全局访问点：提供一个全局访问的方法，让其他对象可以轻松地获取到这个唯一的实例。
iOS设计模式反思之单例模式的进化
程序猿GTC
04-18 1353
实例代码可以从DZSinglonExample找到 单例模式 什么是单例模式？ 单例模式想一个大独裁者，他规定在他的国度里面，所有数据的访问和请求都得经过他，甚至你要调用相关的函数也得经过它。学术一点就是，单例模式，为某一类需求和数据提供了统一的程序接口。主要的实现技术就是，确保全局只有一个对象的实例存在。举个例子把，比如NSNotificationCenter 中的 defaul
设计模式： 单例 工厂
sky274548769的博客
06-04 212
1、设计模式：设计模式就是一种程序的思想的标准，一句话，把简单的问题代码复杂化。 单例模式： package com.xingxue.demo1; /** * 1、构造器私有化，不让外部调用 * 2、定义一个私有静态的的当前对象，内存上永远只有一份 * 3、提供一个公有的静态方法，根据实际情况来创建对象。 * * 懒汉式 * @author Administrator ...
单例工厂模式
weixin_30861797的博客
06-02 71
#pragma once class CPeople { public: CPeople(); virtual ~CPeople(); public: virtual void ReadBook(); }; #include "pch.h" #include "CPeople.h" CPeople::CPeople() { }...
单例模式-工厂模式
Mr_Jin的博客
12-28 4082
一：单例模式 1.单例模式只能有一个实例 2.单例必须自己创建自己的唯一实例 3.单例必须给所以其他对象提供这一实例 在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例，这些应用或多或少具有资源管理器的功能。 单例模式之懒汉单例： //0.创建自己的单例程序 class MySingle2{ //6.2创建一个静态的唯一的锁对象 static Object o = new Object(); //1.私有化本类的构造方法 p
C++ 单例模式的几种实现方式研究
08-26
"C++ 单例模式的几种实现方式研究" 单例模式是设计模式中最常应用的一种模式，也是面试官最喜欢的题目。但是，如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况。 单例模式的主要...
设计模式C++学习之单例模式（Singleton）
09-07
在C++中，还有一些其他的设计模式，如工厂模式、观察者模式、装饰器模式等，它们都有各自的用途和适用场景。理解并熟练运用这些设计模式，能够提高代码的可读性、可维护性和复用性，是每个专业程序员必备的技能。在...
C++单例模式的实例详解
08-29
**C++单例模式详解** 单例模式是一种常用的软件设计模式，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在C++中，单例模式被广泛应用于那些需要全局共享的对象，例如日志系统、数据库连接或配置...
C++中的单例模式.rar
04-06
在C++中，实现单例模式有多种方法，每种都有其优缺点。本篇文章将详细探讨C++中实现单例模式的常见方法，以及它们在实际应用中的考虑因素。 1. **静态成员变量法**： 这是最简单的单例实现方式，通过将实例声明为...
单例、工厂、策略模式C++、qt
01-01
例如，你可以使用单例模式管理Qt应用程序的全局设置，工厂模式用于动态创建和管理不同类型的设备（如device文件中可能包含的各种硬件设备），而策略模式则可用于处理设备的多种工作模式或策略。 通过这样的设计，你...
单例化的工厂模式（批量管理内存池对象）
weixin_41176628的博客
07-01 335
一、首先了解下单例： 单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例; 具体运用场景如： 设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动; 数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取; 如何满足上述情景的需求？ 全局只有一个实例：static 特性，同时禁止用户自己声明并定义实例（把构造函数设为 private） 线程安全 禁止赋值和拷贝 用户通过接口
单例模式、工厂模式
changlinke的博客
01-19 153
单例模式、工厂模式单例模式工厂模式 单例模式 目的：只让某个类创建一个对象 实现步骤： 将构造方法私有化， 目的：不能让用户去独自创建对象。 创建一个公共的静态方法来返回当前对象，并且保证只实例化一次,。 目的：对外提供一个公共的静态方法，使用类调用该方法，能够返回当前类对象。 创建一个私有化的静态变量，用于存储当前类的对象（变量的类型，是当前类类型）。 为什么： ①当调用处通过该方法获取对象的时候，先判断是否已经创建了对象，如果没有就创建一个并存储如果已经创建，就直接返回该对象，所以，需要一个存储对象的
设计模式【单例、工厂】
weixin_42889562的博客
07-05 161
文章目录设计模式单例模式==饿汉式（静态常量）====饿汉式（静态代码块）==懒汉式（线程不安全）懒汉式（线程安全,同步方法）懒汉式（同步代码块）==双重检查====静态内部类====枚举方式==单例模式注意事项工厂模式简单工厂模式（静态工厂模式）工厂方法模式抽象工厂模式 设计模式 是某类问题的通用解决方案 设计模式的本质：提高软件的维护性、通用性、扩展性，并降低软件的复杂度。 设计模式分为三种类型，共 23 种 创建模式（对象的创建应该怎么去设计）： 单例模式（某个类的实例只有一个） 原型模式（怎么去
单例模式/工厂模式
forever_sunny的博客
08-23 376
单例模式 定义：是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。 要点： 1、某个类只能有一个实例 2、它必须自行创建这个实例 3、它必须自行向整个系统提供这个实例 具体描述： 1、 单例模式的类只提供私有的构造函数 2、 类定义中含有一个该类的静态私有对象 3、 该类提供了一个静态的公有的函数用于创建
单例 和 工厂
qq_40708024的博客
04-27 185
       基友们，游戏玩累啦，来写博客。哈哈 ~~ 几乎每次面试过程中，苦逼的我们都会被问到PHP的单利模式和工厂模式。今天大家也各自己写一哈，单例模式三私一共：私有构造方法、私有克隆方法、私有静态变量class Single_case (){        static private  $single_obj = NULL; //创建私有静态存储对象，静态防止多次实例化         p...
单例、工厂模式简介
墨突不黔
08-22 372
一． 设计模式 a. 什么是设计模式？   设计模式是前人经过多次尝试，总结出来的一套行之有效的处理问题的方法。 比如： 用牛耕田        先预习，再学习，并做好复习，是行之有效的学习方法。   在软件编程方面，如何去写程序，并写好程序，提高复用效率，软件大师们经过长时间的摸索，得出一些写代码的一般规律，我们把它叫做“软件编码设计模式”。   在软件开发历史上，有4个人，俗
单例，静态工厂，构造器
u014623470的专栏
06-02 1037
1.effective in java 第一条，尽量用静态方法代替构造器 1.静态工厂不必每次都创建新对象。 如Boolean.valueof(boolean) 实例受控的类，确保是singleton（单例）,或者是不可实例化的。 singleton 仅被实例化一次的类， 注意几点 singleton构造方法必须私有，使得无法通过new来生成第二个实例， 对象仅有一个，尤其在多
c++ 工厂模式
05-27
在 C++ 中使用工厂模式更为常见，因为 C++ 支持面向对象编程。下面是一个 C++ 工厂模式的例子，使用了抽象基类和纯虚函数： ```c++ #include <iostream> using namespace std; // 定义抽象基类 class Shape { public: virtual void draw() = 0; virtual ~Shape() {} }; // 定义具体类 class Rectangle : public Shape { public: void draw() { cout << "This is a rectangle." << endl; } }; class Circle : public Shape { public: void draw() { cout << "This is a circle." << endl; } }; // 定义工厂类 class ShapeFactory { public: Shape* createShape(char type) { switch (type) { case 'r': return new Rectangle(); case 'c': return new Circle(); default: return NULL; } } }; int main() { ShapeFactory factory; Shape* shape1 = factory.createShape('r'); Shape* shape2 = factory.createShape('c'); shape1->draw(); shape2->draw(); delete shape1; delete shape2; return 0; } ``` 在上面的代码中，我们定义了一个抽象基类 `Shape`，它有一个纯虚函数 `draw`，用于在派生类中实现。然后，我们又定义了两个具体类 `Rectangle` 和 `Circle`，它们分别继承自 `Shape`，并实现了 `draw` 函数。 接下来，我们定义了一个工厂类 `ShapeFactory`，它有一个函数 `createShape`，根据类型参数创建相应的对象。如果类型参数是 `'r'`，则创建一个 `Rectangle` 对象；如果类型参数是 `'c'`，则创建一个 `Circle` 对象。注意，这里我们返回的是 `Shape*` 类型，因为 `Rectangle` 和 `Circle` 类都继承自 `Shape`，所以它们可以被转化为 `Shape` 类型的指针。 最后，我们在 `main` 函数中使用工厂类创建了两个对象，并调用它们的 `draw` 函数输出了对象的信息。注意，我们在程序结束时需要手动释放对象占用的内存。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WISHMELUCK1'

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值