首页 > 编程语言 >C++设计模式

C++设计模式

时间：2024-09-28 10:47:55浏览次数：8  
标签：std unique void C++ class virtual 设计模式 public

C++设计模式提供了一些常见的问题和解决方案，帮助我们写出更清晰、更高效、更容易维护的代码。

1.单例模式：就像整形诊所里有一个特别的规定，全世界只能有一个人拥有某款独一无二的鼻子，其他人都不能复制。

（确保一个类只有一个实例，并提供一个全局访问点。）

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 私有构造函数

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

2.工厂方法模式：就像你告诉整形医生你想要什么样的眼睛，医生会根据你的需求定制，但具体是哪个医生操作，你不需要知道。（定义创建对象的接口，但让子类决定实例化哪一个类。）

// 产品基类
class Product {
public:
    virtual ~Product() {}
    virtual void Use() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void Use() override {
        std::cout << "Using A" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void Use() override {
        std::cout << "Using B" << std::endl;
    }
};

// 工厂基类
class Creator {
public:
    virtual ~Creator() {}
    virtual Product* FactoryMethod() = 0;
};

// 具体工厂A
class ConcreteCreatorA : public Creator {
public:
    Product* FactoryMethod() override {
        return new ConcreteProductA();
    }
};

// 具体工厂B
class ConcreteCreatorB : public Creator {
public:
    Product* FactoryMethod() override {
        return new ConcreteProductB();
    }
};

3.抽象工厂模式：就像一个大型的整形医院，可以提供一整套整形服务，包括眼睛、鼻子、下巴等，你只需要告诉医院你想要一整套整形方案，医院会按照一套标准给你安排。（提供一个创建一系列相关或相互依赖对象的接口，而不需要指定它们具体的类。）

// 产品族A
class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual void UsefulFunctionA() = 0;
};

// 产品族B
class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual void UsefulFunctionB() = 0;
};

// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void UsefulFunctionA() override {
        std::cout << "The result of product A1." << std::endl;
    }
};

// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void UsefulFunctionB() override {
        std::cout << "The result of product B1." << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// 具体工厂
class ConcreteFactory : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA1();
    }
    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB1();
    }
};

4.建造者模式：就像整形手术中的逐步调整，你可以按照不同的步骤和顺序来调整你的面部特征，以达到最终的效果。（将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。）

// 产品类
class Product {
public:
    void Show() {
        std::cout << "Product has been built." << std::endl;
    }
};

// 建造者接口
class Builder {
public:
    virtual ~Builder() {}
    virtual void BuildPartA() = 0;
    virtual void BuildPartB() = 0;
    virtual Product GetResult() = 0;
};

// 具体建造者
class ConcreteBuilder : public Builder {
private:
    Product product;
public:
    void BuildPartA() override {
        std::cout << "Building PartA" << std::endl;
    }
    void BuildPartB() override {
        std::cout << "Building PartB" << std::endl;
    }
    Product GetResult() override {
        return product;
    }
};

// 指挥者
class Director {
public:
    void Construct(Builder* builder) {
        builder->BuildPartA();
        builder->BuildPartB();
    }
};

5.原型模式：就像整形手术中的克隆技术，你可以复制一个已经整形成功的人的脸，而不是从头开始设计。（通过拷贝现有的实例创建新的实例，而不是通过新建一个实例。）

#include <iostream>
#include <memory>

class Prototype {
public:
    virtual ~Prototype() {}
    virtual Prototype* Clone() const = 0;
};

class ConcretePrototype : public Prototype {
private:
    int field;
public:
    ConcretePrototype(int field) : field(field) {}
    Prototype* Clone() const override {
        return new ConcretePrototype(*this);
    }
    void Operation() {
        std::cout << "Prototype " << field << std::endl;
    }
};

int main() {
    std::unique_ptr<Prototype> prototype(new ConcretePrototype(100));
    std::unique_ptr<Prototype> clone = prototype->Clone();
    clone->Operation();
    return 0;
}

6.适配器模式：就像整形手术中的面部调整，让你的面部特征能够适应不同的美学标准。

（允许不兼容的接口协同工作。）

// 目标接口
class Target {
public:
    virtual void Request() = 0;
};

// 客户端需要的类
class Client {
public:
    void UseTarget(Target* target) {
        target->Request();
    }
};

// 被适配的类
class Adaptee {
public:
    void SpecificRequest() {
        std::cout << "Specific Request" << std::endl;
    }
};

// 适配器类
class Adapter : public Target {
private:
    Adaptee* adaptee;
public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}
    void Request() override {
        adaptee->SpecificRequest();
    }
};
  1. 装饰器模式：就像整形手术中的额外装饰，比如纹眉、纹眼线，你可以在不改变面部结构的情况下，增加一些新的美学特征。（动态地给一个对象添加一些额外的职责。）
#include <iostream>
#include <memory>

// 组件接口
class Component {
public:
    virtual ~Component() {}
    virtual void Operation() = 0;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void Operation() override {
        std::cout << "ConcreteComponent" << std::endl;
    }
};

// 装饰器抽象类
class Decorator : public Component {
protected:
    Component* component;
public:
    Decorator(Component* component) : component(component) {}
    void Operation() override {
        component->Operation();
    }
};

// 具体装饰器A
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component* component) : Decorator(component) {}
    void Operation() override {
        Decorator::Operation();
        AddBehavior();
    }
private:
    void AddBehavior() {
        std::cout << "ConcreteDecoratorA" << std::endl;
    }
};

// 具体装饰器B
class ConcreteDecoratorB : public Decorator {
public:
    ConcreteDecoratorB(Component* component) : Decorator(component) {}
    void Operation() override {
        Decorator::Operation();
        AddBehavior();
    }
private:
    void AddBehavior() {
        std::cout << "ConcreteDecoratorB" << std::endl;
    }
};

8.外观模式：就像整形医院的前台，你只需要告诉前台你想要什么样的整形效果，前台会帮你安排所有的手术流程。

（为系统中的一组接口提供一个统一的高层接口。）

// 子系统类A
class SubSystemA {
public:
    void Operation() {
        std::cout << "SubSystemA operation" << std::endl;
    }
};

// 子系统类B
class SubSystemB {
public:
    void Operation() {
        std::cout << "SubSystemB operation" << std::endl;
    }
};

// 外观类
class Facade {
private:
    SubSystemA* subSystemA;
    SubSystemB* subSystemB;
public:
    Facade() {
        subSystemA = new SubSystemA();
        subSystemB = new SubSystemB();
    }
    ~Facade() {
        delete subSystemA;
        delete subSystemB;
    }
    void Operation() {
        subSystemA->Operation();
        subSystemB->Operation();
    }
};

 9.享元模式：就像整形手术中的共享资源，比如共享同一型号的假体，通过共享来减少成本和资源浪费。（通过共享来高效地支持大量的细粒度对象。）

#include <iostream>
#include <unordered_map>
#include <memory>

class Flyweight {
public:
    virtual void Operation(int extrinsicState) = 0;
};

class ConcreteFlyweight : public Flyweight {
private:
    std::string intrinsicState;
public:
    ConcreteFlyweight(const std::string& intrinsicState) : intrinsicState(intrinsicState) {}
    void Operation(int extrinsicState) override {
        std::cout << "ConcreteFlyweight: " << intrinsicState << ", " << extrinsicState << std::endl;
    }
};

class FlyweightFactory {
private:
    std::unordered_map<std::string, std::shared_ptr<Flyweight>> flyweights;
public:
    std::shared_ptr<Flyweight> GetFlyweight(const std::string& key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = std::make_shared<ConcreteFlyweight>(key);
        }
        return flyweights[key];
    }
};

int main() {
    FlyweightFactory factory;
    std::shared_ptr<Flyweight> fw1 = factory.GetFlyweight("Item1");
    std::shared_ptr<Flyweight> fw2 = factory.GetFlyweight("Item1");
    fw1->Operation(10);
    fw2->Operation(20);
    return 0;
}

 10.代理模式就像整形手术中的代理，帮你处理所有的手术安排和后续服务，你只需要和代理沟通。（为其他对象提供一种代理以控制对这个对象的访问。）

#include <iostream>

// 代理类
class Proxy {
private:
    std::unique_ptr<RealSubject> realSubject;
public:
    Proxy() {}
    void Request() {
        if (realSubject == nullptr) {
            realSubject = std::make_unique<RealSubject>();
        }
        realSubject->Request();
    }
};

// 真实主题类
class RealSubject {
public:
    void Request() {
        std::cout << "RealSubject: Handling Request." << std::endl;
    }

 

11.命令模式：就像整形手术中的指令系统，你可以发出指令，比如“我想要这样的鼻子”，然后系统会帮你实现。（将请求封装为一个对象，从而可以使用不同的请求、队列或日志请求。）

#include <iostream>
#include <memory>
#include <vector>

// 命令接口
class Command {
public:
    virtual ~Command() {}
    virtual void Execute() = 0;
};

// 具体命令
class ConcreteCommand : public Command {
private:
    std::unique_ptr<Receiver> receiver;
public:
    ConcreteCommand(std::unique_ptr<Receiver> receiver) : receiver(std::move(receiver)) {}
    void Execute() override {
        receiver->Action();
    }
};

// 接收者
class Receiver {
public:
    void Action() {
        std::cout << "Receiver action." << std::endl;
    }
};

// 调用者
class Invoker {
private:
    std::vector<std::unique_ptr<Command>> commands;
public:
    void StoreAndExecute(Command* cmd) {
        commands.push_back(std::unique_ptr<Command>(cmd));
        cmd->Execute();
    }
};

int main() {
    std::unique_ptr<Receiver> receiver = std::make_unique<Receiver>();
    std::unique_ptr<Command> command = std::make_unique<ConcreteCommand>(std::move(receiver));
    std::unique_ptr<Invoker> invoker = std::make_unique<Invoker>();
    invoker->StoreAndExecute(command.get());
    return 0;
}

 12.观察者模式：就像整形手术后的跟踪服务，一旦有新的整形技术或者你的恢复情况有更新，医院会及时通知你。（当对象间存在一对多关系时，则使用观察者模式。）

#include <iostream>
#include <list>
#include <algorithm>

// 观察者接口
class Observer {
public:
    virtual ~Observer() {}
    virtual void Update(int state) = 0;
};

// 具体观察者
class ConcreteObserver : public Observer {
public:
    void Update(int state) override {
        std::cout << "ConcreteObserver: " << state << std::endl;
    }
};

// 主题接口
class Subject {
public:
    virtual ~Subject() {}
    virtual void Attach(Observer* observer) = 0;
    virtual void Detach(Observer* observer) = 0;
    virtual void Notify() = 0;
};

// 具体主题
class ConcreteSubject : public Subject {
private:
    std::list<Observer*> observers;
    int state;
public:
    void Attach(Observer* observer) override {
        observers.push_back(observer);
    }
    void Detach(Observer* observer) override {
        observers.remove(observer);
    }
    void Notify() override {
        for (Observer* observer : observers) {
            observer->Update(state);
        }
    }
    void ChangeState(int newState) {
        state = newState;
        Notify();
    }
};

int main() {
    std::unique_ptr<ConcreteSubject> subject = std::make_unique<ConcreteSubject>();
    std::unique_ptr<ConcreteObserver> observer = std::make_unique<ConcreteObserver>();
    subject->Attach(observer.get());
    subject->ChangeState(1);
    subject->Detach(observer.get());
    subject->ChangeState(2);
    return 0;
}
  1. 策略模式：就像整形手术中的不同整形方案，你可以根据不同的需求选择不同的整形策略，随时可以更换。（定义一系列算法，把它们一个个封装起来，并使它们可以相互替换。） 
    #include <iostream>
#include <memory>

// 策略接口
class Strategy {
public:
    virtual ~Strategy() {}
    virtual void AlgorithmInterface() = 0;
};

// 具体策略A
class ConcreteStrategyA : public Strategy {
public:
    void AlgorithmInterface() override {
        std::cout << "ConcreteStrategyA" << std::endl;
    }
};

// 具体策略B
class ConcreteStrategyB : public Strategy {
public:
    void AlgorithmInterface() override {
        std::cout << "ConcreteStrategyB" << std::endl;
    }
};

// 上下文
class Context {
private:
    std::unique_ptr<Strategy> strategy;
public:
    void SetStrategy(std::unique_ptr<Strategy> strategy) {
        this->strategy = std::move(strategy);
    }
    void ExecuteStrategy() {
        strategy->AlgorithmInterface();
    }
};

int main() {
    std::unique_ptr<Context> context = std::make_unique<Context>();
    context->SetStrategy(std::make_unique<ConcreteStrategyA>());
    context->ExecuteStrategy();
    context->SetStrategy(std::make_unique<ConcreteStrategyB>());
    context->ExecuteStrategy();
    return 0;
}

 模板方法模式：就像整形手术中的手术流程模板，定义了手术的基本步骤，但具体每一步怎么做，可以根据每个人的情况来调整。（在方法中定义算法的骨架，而将一些步骤延迟到子类中实现。）

#include <iostream>

// 抽象类
class AbstractClass {
public:
    virtual ~AbstractClass() {}
    void TemplateMethod() {
        PrimitiveOperation1();
        PrimitiveOperation2();
        ConcreteOperation();
    }
    virtual void ConcreteOperation() = 0;
protected:
    void PrimitiveOperation1() {
        std::cout << "AbstractClass: PrimitiveOperation1" << std::endl;
    }
    void PrimitiveOperation2() {
        std::cout << "AbstractClass: PrimitiveOperation2" << std::endl;
    }
};

// 具体实现A
class ConcreteClassA : public AbstractClass {
public:
    void ConcreteOperation() override {
        std::cout << "ConcreteClassA: ConcreteOperation" << std::endl;
    }
};

// 具体实现B
class ConcreteClassB : public AbstractClass {
public:
    void ConcreteOperation() override {
        std::cout << "ConcreteClassB: ConcreteOperation" << std::endl;
    }
};

int main() {
    std::unique_ptr<AbstractClass> objectA = std::make_unique<ConcreteClassA>();
    objectA->TemplateMethod();
    std::unique_ptr<AbstractClass> objectB = std::make_unique<ConcreteClassB>();
    objectB->TemplateMethod();
    return 0;
}
  1. 访问者模式：就像整形手术后的回访，医生会根据不同的恢复情况来提供不同的护理建议。（允许一个或者多个操作应用到一组对象上，解耦操作和对象本身。）
#include <iostream>
#include <vector>
#include <memory>

// 元素接口
class Element {
public:
    virtual ~Element() {}
    virtual void Accept(class Visitor* visitor) = 0;
};

// 具体元素A
class ConcreteElementA : public Element {
public:
    void Accept(Visitor* visitor) override {
        visitor->Visit(this);
    }
    void OperationA() {
        std::cout << "ConcreteElementA" << std::endl;
    }
};

// 具体元素B
class ConcreteElementB : public Element {
public:
    void Accept(Visitor* visitor) override {
        visitor->Visit(this);
    }
    void OperationB() {
        std::cout << "ConcreteElementB" << std::endl;
    }
};

// 访问者接口
class Visitor {
public:
    virtual ~Visitor() {}
    virtual void Visit(ConcreteElementA* element) = 0;
    virtual void Visit(ConcreteElementB* element) = 0;
};

// 具体访问者
class ConcreteVisitor : public Visitor {
public:
    void Visit(ConcreteElementA* element) override {
        element->OperationA();
    }
    void Visit(ConcreteElementB* element) override {
        element->OperationB();
    }
};

int main() {
    std::vector<std::unique_ptr<Element>> elements;
    elements.push_back(std::make_unique<ConcreteElementA>());
    elements.push_back(std::make_unique<ConcreteElementB>());

    std::unique_ptr<Visitor> visitor = std::make_unique<ConcreteVisitor>();

    for (auto& element : elements) {
        element->Accept(visitor.get());
    }
    return 0;
}

 

标签：std,unique,void,C++,class,virtual,设计模式,public
From： https://blog.csdn.net/empwzj/article/details/142461215

相关文章

  • C C++ 强制类型转换
    强制类型转换概念在C语言中，强制类型转换（强转）是一种将一个数据类型的值转换为另一个数据类型的操作。它允许程序员显式地改变表达式的数据类型。语法强转的语法形式为：(目标类型)表达式。例如，(int)3.14会将浮点数3.14强制转换为整数类型，结果为3。作用不同类型数据运算时......
  • 结构型设计模式详解与对比：优化你的系统设计
    结构型设计模式（StructuralDesignPatterns）主要关注类和对象的组合，以形成更大的结构。它们通过识别实体之间的关系，帮助设计师确保系统的各个部分能够协同工作。以下是几种常见的结构型设计模式及其详细介绍和对比：一,代理模式（ProxyPattern）用途:为另一个对象提供一个替身......
  • 【C++】string中常用的接口
    目录前言常用接口1.有/无参string2.字符串相加3.string类对象的访问及遍历操作3.1普通遍历3.2迭代器遍历3.3范围for4.string类对象的修改操作前言今天分享一些个人认为string常用的接口，大多数资料来自于cplusplus，其他不常用的平常查阅资料使用即可。需要测试代......
  • 【C++基础知识——如何判断是注入依赖还是赋值？】
    问题template<typenameType,typenameEventlist,typenameEventlist,typenameRejectEventList,typenameQueuedEventHandler>classParallelProcedureQueueManager{explicitParallelProcedureQueueManager(Type&equipment,con......
  • C++ 容器赋值运算符
    ▲《C++Primer》P302assignlist<string>names;vector<constchar*>old_c_str{"娃哈哈","孟菲斯","HelloWold!"};names.assign(old_c_str.cbegin(),old_c_str.cend());//这个可以，拷贝构造for(constautos:names){cout......
  • 题解 HZOJ 284 超市卖货 C/C++
    题目传送门：超市卖货-题目-OnlineJudge(haizeix.com)https://oj.haizeix.com/problem/284思路：每次寻找价格最高的商品，并尝试卖掉它：寻找未卖出商品的日期，优先锁定其保质期最后一天，若该日期已卖出则继续向前寻找能找到未卖出商品的日期时，收入增加，标记该日期代码实现：为......
  • C++引用的基本概念，引用的定义与使用
    C++中的引用（Reference）是一种复合类型，它是某个已存在变量的别名（alias）。换句话说，引用在内部存储了另一个变量的地址，但是与指针不同的是，引用在定义时必须被初始化，并且一旦被初始化后，它就不能再被改变为引用另一个变量（即引用一旦绑定到一个变量，就不能再被绑定到另一个变量）。此外，引......
  • C++字符串与字符数组
    在C++中，字符串和字符数组是紧密相关的概念，但它们之间也存在一些关键的区别。理解这些区别对于编写高效、安全的C++代码非常重要。字符数组字符数组是C++中用于存储字符序列的基础数据结构。它本质上是一个元素类型为char的数组，可以在声明时初始化，也可以在运行时通过赋值或函......
  • C++线程同步之条件变量
    条件变量需要和互斥量配合起来使用，C++11提供了两种条件变量：condition_variable：需要配合std::unique_lockstd::mutex进行wait操作，也就是阻塞线程的操作。condition_variable_any：可以和任意带有lock()、unlock()语义的mutex搭配使用，也就是说有四种：std::mutex：独占的非递归互斥锁......
  • 算法速通-90题（1—完数难题）[含pyhton，java，c++]
    题目：完数难题 题目描述如下：    小明正在进行期末数学考试，现在他遇到了这样一个题：如果一个大于1的正整数的所有因子之和等于它的本身，则称这个数是完数   比如6，28都是完数：6=1+2+3 ； 28=1+2+4+7+14。请判断两个正整数之间完数的个数。小明想请聪明的你帮......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99