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

已于 2024-06-20 14:21:28 修改
阅读量350 收藏 1
点赞数 5
文章标签： 设计模式 算法
于 2024-06-20 11:29:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41199566/article/details/139827363
版权

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;
}

九十岁也要程序猿
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《C++ 设计模式》
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
C++设计模式 - 创建型模式之工厂模式
kakaka666的博客
06-11 1611
工厂模式最直观的理解是，减少new创建对象的方式，用接口的方式来返回一个对象，而new创建的方式被封装了简单工厂：调用者只需使用单例工厂就可获取同一范畴的所有产品工厂方法：调用者并不知道它在运行时会获取何种产品，只知道某个特定的工厂能生成出满足需求的产品抽象工厂：调用者可以在运行时从特定的工厂中获得所有信息相关的产品簇(可以对产品进行组合)
3.C++设计模式-创建型模型
weixin_42636062的博客
08-26 3015
3.C++设计模式-工厂模式 3.1 简单工厂模式 3.1.1 理论 3.1.2 简单工厂模式案例 不难看出，Fruit类是一个“巨大的”类，在该类的设计中存在如下几个问题： (1) 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，代码越长，阅读难度、维护难度和测试难度也越大；而且大量条件语句的存在还将影响系统的性能，程序在执行过程中需要做大量的条件判断。 (2) Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水果对象的初始化代码和显示代码集中在一个类中实现
c++设计模式详解_创建型设计模式
weixin_46935110的博客
07-17 2699
c++设计模式详解_创建型设计模式
C++设计模式之——命令模式
肩上风骋的博客
12-18 1403
命令模式是一种行为型设计模式，它允许将请求封装为一个对象，从而使得可以参数化客户端请求、将请求排队或者记录请求日志，以及支持可撤销的操作。总的来说，命令模式的应用场景主要在于解耦请求与实现，封装接收方具体命令的实现细节，使得请求方的代码架构稳定，具备良好的扩展性。2.创建具体命令类（Concrete Command）：继承自抽象命令类，实现具体的命令操作，同时持有一个命令接收者对象。在C++中，命令模式通常由一个抽象命令类、具体命令类、命令接收者类和调用者类组成。
C++ 设计模式之 中介者模式
K1_uestc的博客
01-18 1718
第一行包括一个整数N,表示用户的数量（1
C++ 设计模式之责任链模式
K1_uestc的博客
01-25 1438
-什么是责任链模式（第21种设计模式）责任链模式是⼀种行为型设计模式，它允许你构建⼀个对象链，让请求从链的⼀端进⼊，然后沿着链上的对象依次处理，直到链上的某个对象能够处理该请求为止。职责链上的处理者就是⼀个对象，可以对请求进⾏处理或者将请求转发给下⼀个节点，这个场景在⽣活中很常⻅，就是⼀个逐层向上递交的过程，最终的请求要么被处理者所处理，要么处理不了，这也因此可能导致请求⽆法被处理。【组成结构】1.处理者Handler：定义⼀个处理请求的接⼝，包含⼀个处理请求的抽象⽅法和⼀个指向下⼀个处理者的链接。
C++ 设计模式之备忘录模式
K1_uestc的博客
01-19 1682
对于每个 "Increment" 和 "Decrement" 操作，输出当前计数器的值，计数器数值从0开始 对于每个 "Undo" 操作，输出撤销后的计数器值。输入包含若干行，每行包含一个字符串，表示计数器应用的操作，操作包括 "Increment"、 "Decrement"、"Undo" 和 "Redo"。备忘录有两个接⼝，发起⼈能够通过宽接⼝访问数据，管理者只能看到窄接⼝，并将备忘录传递给其他对象。UndoManager 和UndoableEdit 接⼝是与备忘录模式相关的主要类和接⼝。
C++设计模式|创建型 1.单例模式
Brillian123的博客
04-12 1430
单例模式的的核⼼思想在创建类对象的时候保证⼀个类只有⼀个实例，并提供⼀个全局访问点来访问这个实例。只有⼀个实例的意思是，在整个应⽤程序中，只存在该类的⼀个实例对象，⽽不是创建多个相同类型的对象。全局访问点的意思是，为了让其他类能够获取到这个唯⼀实例，该类提供了⼀个全局访问点（通常是⼀个静态⽅法），通过这个⽅法就能获得实例。
设计模式之工厂模式(C++)
热门推荐
翟天保的博客
02-15 2万+
介绍设计模式之工厂模式
c++设计模式-创建型模式-建造者模式
06-04
**建造者模式（Builder Pattern）**是软件设计模式中的一种创建型模式，它允许我们分步骤构建复杂的对象，而无需暴露构建过程。在C++中，这种模式常用于将对象的创建过程与使用过程分离，使得对象的构建更加灵活，...
C++设计模式之享元模式（Flyweight）
08-27
C++设计模式之享元模式（Flyweight）是一种结构型设计模式，主要用于解决大量相似对象的创建和操作所带来的内存负载问题。该模式的主要设计目标是通过共享对象来减少内存负载，提高系统的性能。 享元模式顾名思义...
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
C++设计模式之组合模式(Composite)
08-27
C++设计模式之组合模式（Composite） 组合模式（Composite）是一种结构型设计模式，用于描述分支包含关系，也就是我们说的树形关系。其对象分为枝和叶，每一枝可包含枝和叶，直到全部为叶节点。 组合模式的主要...
c++设计模式-工厂方法模式
06-04
在标题“c++设计模式-工厂方法模式”中，我们关注的是如何在C++中实现工厂方法这一设计模式。工厂方法模式的核心思想是定义一个创建对象的接口，但让子类决定实例化哪一个类。这样，工厂方法可以使类的实例化过程...
优化接口的几个常用方法
qq_40592590的博客
06-28 721
优化接口
【原创实现 设计模式】Spring+策略+模版+工厂模式去掉if-else，实现开闭原则，优雅扩展
最新发布
一名Java后端程序员，分享日常bug和一些好玩的东西！
06-29 383
【原创实现 设计模式】Spring+策略+模版+工厂模式去掉if-else，实现开闭原则，优雅扩展
设计模式概述
java666668888的博客
06-29 330
通过本文，我们深入学习了《Head First设计模式》中的几种经典设计模式，并通过代码示例演示了它们的基本实现和应用场景。《Head First设计模式》一书系统地介绍了23种经典的设计模式，分为三大类：创建型模式、结构型模式和行为型模式。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨《Head First设计模式》这本经典著作中介绍的设计模式，以及它们在实际应用中的场景分析。
组合设计模式
技术分享
06-27 141
组合设计模式是一种结构型设计模式，主要用于将对象组合成树形结构以表示“部分-整体”的层次结构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值