当前位置： 首页 > news >正文

c++设计模式之一创建型模式

news 来源：原创 2024/9/29 21:26:15

1、创建型模式（常见的设计模式）

Factory 模式（工厂模式，被实例化的子类）

在面向对象系统设计中经常可以遇到以下的两类问题：

下面是第一类问题和代码示例：我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。所以就不得不在要用到子类的地方写new 对象。这样实体类的使用者必须知道实际的子类名称，以及会使程序的扩展性和维护变得越来越困难。

#include <iostream>// 抽象基类或接口
class Animal {
public:virtual void makeSound() = 0; // 纯虚函数
};// 具体子类
class Dog : public Animal {
public:void makeSound() override {std::cout << "Woof!" << std::endl;}
};class Cat : public Animal {
public:void makeSound() override {std::cout << "Meow!" << std::endl;}
};int main() {Animal* animal;// 通过指向基类的指针指向具体的子类实例animal = new Dog();animal->makeSound();animal = new Cat();animal->makeSound();return 0;
}

在上述示例中，我们定义了一个抽象基类 Animal，其中包含一个纯虚函数 makeSound()。然后我们派生出两个具体的子类 Dog 和 Cat，并分别实现了 makeSound() 方法。在 main() 函数中，我们使用指向基类的指针 animal，通过 new 实例化具体的子类，并调用其方法。这样可以实现多态性，但使用者需要知道具体的子类名称，不利于程序的扩展性和维护。 

还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。只能在父类中写方法调用，具体调用哪一个类的方法交给子类实现。

#include <iostream>// 抽象基类
class Animal {
public:virtual void makeSound() = 0; // 纯虚函数void performAction() {std::cout << "Performing action: ";makeSound();}
};// 具体子类
class Dog : public Animal {
public:void makeSound() override {std::cout << "Woof!" << std::endl;}
};class Cat : public Animal {
public:void makeSound() override {std::cout << "Meow!" << std::endl;}
};int main() {Animal* animal = nullptr;int choice;std::cout << "Enter 1 for Dog, 2 for Cat: ";std::cin >> choice;// 根据用户的选择实例化不同的子类if (choice == 1) {animal = new Dog();} else if (choice == 2) {animal = new Cat();} else {std::cout << "Invalid choice" << std::endl;return 0;}animal->performAction();delete animal;return 0;
}

在上述示例中，我们仍然有一个抽象基类 Animal，其中包含一个纯虚函数 makeSound()。不同之处在于，在 Animal 类中我们添加了一个 performAction() 方法，该方法调用了 makeSound() 方法。在 main() 函数中，根据用户的选择实例化不同的子类，并通过基类指针调用 performAction() 方法。这样，具体调用哪个子类的方法由子类自己实现，父类并不知道具体的子类实例化。

以上两个问题也就引出了 Factory 模式的两个最重要的功能：
1）定义创建对象的接口，封装了对象的创建。
2）使得具体化类的工作延迟到了子类中。

工厂模式代码示例

#include <iostream>
#include <string>// 抽象产品类
class Product {
public:virtual void use() const = 0;
};// 具体产品类 A
class ConcreteProductA : public Product {
public:void use() const override {std::cout << "Using ConcreteProductA" << std::endl;}
};// 具体产品类 B
class ConcreteProductB : public Product {
public:void use() const override {std::cout << "Using ConcreteProductB" << std::endl;}
};// 工厂类
class Factory {
public:virtual Product* createProduct() const = 0;Product* getProduct() const {Product* product = createProduct();// 可以在这里添加其他的初始化逻辑return product;}
};// 具体工厂类 A
class ConcreteFactoryA : public Factory {
public:Product* createProduct() const override {return new ConcreteProductA();}
};// 具体工厂类 B
class ConcreteFactoryB : public Factory {
public:Product* createProduct() const override {return new ConcreteProductB();}
};int main() {Factory* factory = nullptr;Product* product = nullptr;std::string choice;std::cout << "Enter A for ConcreteProductA, B for ConcreteProductB: ";std::cin >> choice;// 根据用户的选择实例化不同的具体工厂类if (choice == "A") {factory = new ConcreteFactoryA();} else if (choice == "B") {factory = new ConcreteFactoryB();} else {std::cout << "Invalid choice" << std::endl;return 0;}// 使用工厂类创建产品对象product = factory->getProduct();product->use();delete factory;delete product;return 0;
}

AbstactFactory 模式 （产品对象家族）

假如我们要买水果，水果的产地来自中国、日本、美国，每个国家的水果种类都可以分为苹果、香蕉、梨子。作为开发者，我们就不得不创建苹果类（香蕉和梨子类似），然后每种苹果都继承自苹果类。每上架一个国家的苹果我们都要实现一次苹果类，这样就会有成千上万的苹果类需要被创建，AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

//抽象工厂模式
#include <iostream>
using namespace std;//苹果的抽象
class AbstractApple {
public:virtual void showName() = 0;
};//中国苹果
class ChinaApple :public AbstractApple {
public:virtual void showName() {cout << "中国苹果" << endl;}
};//美国苹果
class USAApple :public AbstractApple {
public:virtual void showName() {cout << "美国苹果" << endl;}
};//日本苹果
class JapanApple :public AbstractApple {
public:virtual void showName() {cout << "日本苹果" << endl;}
};//香蕉的抽象
class AbstractBanana {
public:virtual void showName() = 0;
};//中国香蕉
class ChinaBanana :public AbstractBanana {
public:virtual void showName() {cout << "中国香蕉" << endl;}
};//美国香蕉
class USABanana :public AbstractBanana {
public:virtual void showName() {cout << "美国香蕉" << endl;}
};//日本香蕉
class JapanBanana :public AbstractBanana {
public:virtual void showName() {cout << "日本香蕉" << endl;}
};//鸭梨的抽象
class AbstractPear {
public:virtual void showName() = 0;
};//中国鸭梨
class ChinaPear :public AbstractPear {
public:virtual void showName() {cout << "中国鸭梨" << endl;}
};//美国鸭梨
class USAPear :public AbstractPear {
public:virtual void showName() {cout << "美国鸭梨" << endl;}
};//日本鸭梨
class JapanPear :public AbstractPear {
public:virtual void showName() {cout << "日本鸭梨" << endl;}
};//抽象工厂  针对产品族
class AbstractFactory {
public:virtual AbstractApple* CreateApple() = 0;virtual AbstractBanana* CreateBanana() = 0;virtual AbstractPear* CreatePear() = 0;
};//中国工厂
class ChinaFactory :public AbstractFactory {virtual AbstractApple* CreateApple() {return new ChinaApple;}virtual AbstractBanana* CreateBanana() {return new ChinaBanana;}virtual AbstractPear* CreatePear() {return new ChinaPear;}
};//美国工厂
class USAFactory :public AbstractFactory {virtual AbstractApple* CreateApple() {return new USAApple;}virtual AbstractBanana* CreateBanana() {return new USABanana;}virtual AbstractPear* CreatePear() {return new USAPear;}
};//日本工厂
class JapanFactory :public AbstractFactory {virtual AbstractApple* CreateApple() {return new JapanApple;}virtual AbstractBanana* CreateBanana() {return new JapanBanana;}virtual AbstractPear* CreatePear() {return new JapanPear;}
};void test01() {AbstractFactory* factory = NULL;AbstractApple* apple = NULL;AbstractBanana* Banana = NULL;AbstractPear* Pear = NULL;//中国工厂factory = new ChinaFactory;apple = factory->CreateApple();Banana = factory->CreateBanana();Pear = factory->CreatePear();apple->showName();Banana->showName();Pear->showName();delete Pear;delete apple;delete Banana;delete factory;
}int main()
{test01();
}

Singleton 模式（ 单例模式，针对一个类的唯一实例）
Singleton 模式是设计模式中最为简单、最为常见、最容易实现，也是最应该熟悉和掌握的模式。Singleton 模式就是一个类只创建一个唯一的对象，即一次创建多次使用。

实现单例模式的步骤：
1、构造函数私有化
2、增加静态私有的当前类的指针变量
3、提供静态对外接口,可以让用户获得单例对象

单例分为懒汉式和饿汉式

懒汉式：解决了饿汉式内存浪费问题，但是线程不安全的，可以通过互斥量mutex.lock()和mutex.unlock()来解决，懒汉用的比较多
饿汉式：还没有使用该单例对象，该单例对象就已经被加载到内存了，在对象过多时会造成内存浪费，饿汉模式会在程序启动时就创建单例对象，并且该对象会一直存在于内存中，即使在程序执行过程中没有被使用。这可能会导致内存浪费，特别是在单例对象比较大或者创建单例对象需要消耗大量资源的情况下。

这个是饿汉模式，返回的是一个静态变量，静态变量没运行就会产生数据

class Singleton {
private:static Singleton instance;Singleton() {}public:static Singleton& getInstance() {return instance;}void doSomething() {std::cout << "Singleton instance is doing something." << std::endl;}
};Singleton Singleton::instance;int main() {Singleton& singleton = Singleton::getInstance();singleton.doSomething();return 0;
}

这个是懒汉模式，返回的是一个静态变量指针，程序调用getinstance才会产生数据

#include <iostream>
#include <mutex>class Singleton {
private://类外定义成员变量static Singleton* instance;static std::mutex mutex;//构造函数私有化Singleton() {}public:static Singleton* getInstance() {if (instance == nullptr) {std::lock_guard<std::mutex> lock(mutex);if (instance == nullptr) {instance = new Singleton();}}return instance;}void doSomething() {std::cout << "Singleton instance is doing something." << std::endl;}
};Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;int main() {Singleton* singleton = Singleton::getInstance();singleton->doSomething();return 0;
}

相关文章：

  • 1964springboot VUE 智慧社区可视化平台系统开发mysql数据库web结构java编程计算机网页源码maven项目
  • 问题解决：Problem exceeding maximum token in azure openai (with java)
  • 分布式光纤测温DTS使用的单模光纤与多模光纤有何区别？
  • Leetcode - 周赛401
  • 八大经典排序算法
  • kali中安装docker
  • SARscape——Lee滤波
  • celery使用 Zookeeper 或 kafka 作为broker，使用 mysql 作为 backend
  • POSTMAN接口详解
  • CentOS Linux 7系统中离线安装MySQL5.7步骤
  • Zabbix 7.0 LTS新特征
  • xss-lab靶场level1-level10
  • Centos7升级K8S集群
  • YOLOv10改进 | Neck | 添加双向特征金字塔BiFPN【含二次独家创新】
  • RK3568技术笔记十四 Ubuntu创建共享文件夹
  • 【comparator, comparable】小总结
  • css布局，左右固定中间自适应实现
  • Python语法速览与机器学习开发环境搭建
  • Spring-boot 启动时碰到的错误
  • Vue 重置组件到初始状态
  • 闭包--闭包之tab栏切换(四)
  • 力扣(LeetCode)22
  • 前端知识点整理（待续）
  • 浅谈Golang中select的用法
  • 如何使用Mybatis第三方插件--PageHelper实现分页操作
  • 树莓派 - 使用须知
  • 腾讯优测优分享 | Android碎片化问题小结——关于闪光灯的那些事儿
  • 详解NodeJs流之一
  • 小程序开发之路（一）
  • Semaphore
  • ‌内网穿透技术‌总结
  • $(function(){})与(function($){....})(jQuery)的区别
  • （ 用例图）定义了系统的功能需求，它是从系统的外部看系统功能，并不描述系统内部对功能的具体实现
  • （C语言）fread与fwrite详解
  • （C语言）深入理解指针2之野指针与传值与传址与assert断言
  • （MTK）java文件添加简单接口并配置相应的SELinux avc 权限笔记2
  • (PyTorch)TCN和RNN/LSTM/GRU结合实现时间序列预测
  • （八）光盘的挂载与解挂、挂载CentOS镜像、rpm安装软件详细学习笔记
  • （板子）A* astar算法，AcWing第k短路+八数码 带注释
  • (非本人原创)我们工作到底是为了什么？​——HP大中华区总裁孙振耀退休感言（r4笔记第60天)...
  • （九十四）函数和二维数组
  • （六）激光线扫描-三维重建
  • (十六)、把镜像推送到私有化 Docker 仓库
  • (四)软件性能测试
  • （一）SvelteKit教程：hello world
  • .bat批处理（八）：各种形式的变量%0、%i、%%i、var、%var%、!var!的含义和区别
  • .NET CF命令行调试器MDbg入门（四） Attaching to Processes
  • .NET Core 网络数据采集 -- 使用AngleSharp做html解析
  • .net生成的类，跨工程调用显示注释
  • .net网站发布－允许更新此预编译站点
  • .net最好用的JSON类Newtonsoft.Json获取多级数据SelectToken
  • 。Net下Windows服务程序开发疑惑
  • ::before和::after 常见的用法
  • @RequestMapping用法详解
  • @Transaction注解失效的几种场景（附有示例代码）