【C++】八大常见的设计模式

---

八大常见的设计模式

设计模式是一种编写代码的方式，旨在解决常见的软件设计问题。这些模式提供了代码重用和易于维护的解决方案。本文将讲解几种常见的设计模式，并使用C++编写相应的代码示例。

1. 单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。

饿汉式单例模式

饿汉式单例模式在类加载时就初始化实例，线程安全。

#include <iostream>

class Singleton {
private:
    // 构造函数私有化
    Singleton() {}
    // 静态实例
    static Singleton* instance;

public:
    // 获取单例实例
    static Singleton* getInstance() {
        return instance;
    }

    void print() {
        std::cout << "Hello Singleton..." << std::endl;
    }
};

// 在类加载时初始化实例
Singleton* Singleton::instance = new Singleton();

int main() {
    Singleton* singleton = Singleton::getInstance();
    singleton->print();
    return 0;
}

懒汉式单例模式

懒汉式单例模式在第一次使用时初始化实例，懒加载，节省资源，但需要考虑线程安全。

#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 print() {
        std::cout << "Hello Singleton..." << std::endl;
    }
};

// 静态成员变量初始化
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

int main() {
    Singleton* singleton = Singleton::getInstance();
    singleton->print();
    return 0;
}

2. 工厂设计模式

工厂模式用于创建对象的实例，而不需要指定具体的类。

普通工厂模式

#include <iostream>
#include <string>

class Sender {
public:
    virtual void Send() = 0;
    virtual ~Sender() {}
};

class MailSender : public Sender {
public:
    void Send() override {
        std::cout << "This is mail sender..." << std::endl;
    }
};

class SmsSender : public Sender {
public:
    void Send() override {
        std::cout << "This is sms sender..." << std::endl;
    }
};

class Factory {
public:
    static Sender* produce(const std::string& type) {
        if (type == "mail") {
            return new MailSender();
        } else if (type == "sms") {
            return new SmsSender();
        } else {
            std::cerr << "Invalid type..." << std::endl;
            return nullptr;
        }
    }
};

int main() {
    Sender* sender = Factory::produce("mail");
    if (sender) {
        sender->Send();
        delete sender;
    }
    return 0;
}

多个工厂方法模式

#include <iostream>

class Sender {
public:
    virtual void Send() = 0;
    virtual ~Sender() {}
};

class MailSender : public Sender {
public:
    void Send() override {
        std::cout << "This is mail sender..." << std::endl;
    }
};

class SmsSender : public Sender {
public:
    void Send() override {
        std::cout << "This is sms sender..." << std::endl;
    }
};

class SendFactory {
public:
    Sender* produceMail() {
        return new MailSender();
    }

    Sender* produceSms() {
        return new SmsSender();
    }
};

int main() {
    SendFactory factory;
    Sender* sender = factory.produceMail();
    if (sender) {
        sender->Send();
        delete sender;
    }
    return 0;
}

静态工厂方法模式

#include <iostream>

class Sender {
public:
    virtual void Send() = 0;
    virtual ~Sender() {}
};

class MailSender : public Sender {
public:
    void Send() override {
        std::cout << "This is mail sender..." << std::endl;
    }
};

class SmsSender : public Sender {
public:
    void Send() override {
        std::cout << "This is sms sender..." << std::endl;
    }
};

class SendFactory {
public:
    static Sender* produceMail() {
        return new MailSender();
    }

    static Sender* produceSms() {
        return new SmsSender();
    }
};

int main() {
    Sender* sender = SendFactory::produceMail();
    if (sender) {
        sender->Send();
        delete sender;
    }
    return 0;
}

抽象工厂模式

#include <iostream>

class Sender {
public:
    virtual void Send() = 0;
    virtual ~Sender() {}
};

class MailSender : public Sender {
public:
    void Send() override {
        std::cout << "This is mail sender..." << std::endl;
    }
};

class SmsSender : public Sender {
public:
    void Send() override {
        std::cout << "This is sms sender..." << std::endl;
    }
};

class Provider {
public:
    virtual Sender* produce() = 0;
    virtual ~Provider() {}
};

class SendMailFactory : public Provider {
public:
    Sender* produce() override {
        return new MailSender();
    }
};

class SendSmsFactory : public Provider {
public:
    Sender* produce() override {
        return new SmsSender();
    }
};

int main() {
    Provider* provider = new SendMailFactory();
    Sender* sender = provider->produce();
    if (sender) {
        sender->Send();
        delete sender;
    }
    delete provider;
    return 0;
}

3. 建造者模式

建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

#include <iostream>
#include <vector>
#include <string>

class Computer {
private:
    std::vector<std::string> parts;

public:
    void Add(const std::string& part) {
        parts.push_back(part);
    }

    void Show() {
        for (const auto& part : parts) {
            std::cout << "Component: " << part << " assembled." << std::endl;
        }
        std::cout << "Computer assembled." << std::endl;
    }
};

class Builder {
public:
    virtual void BuildCPU() = 0;
    virtual void BuildMainboard() = 0;
    virtual void BuildHD() = 0;
    virtual Computer* GetComputer() = 0;
    virtual ~Builder() {}
};

class ConcreteBuilder : public Builder {
private:
    Computer* computer;

public:
    ConcreteBuilder() {
        computer = new Computer();
    }

    void BuildCPU() override {
        computer->Add("CPU");
    }

    void BuildMainboard() override {
        computer->Add("Mainboard");
    }

    void BuildHD() override {
        computer->Add("Hard Disk");
    }

    Computer* GetComputer() override {
        return computer;
    }

    ~ConcreteBuilder() {
        delete computer;
    }
};

class Director {
public:
    void Construct(Builder* builder) {
        builder->BuildCPU();
        builder->BuildMainboard();
        builder->BuildHD();
    }
};

int main() {
    Director director;
    ConcreteBuilder builder;

    director.Construct(&builder);
    Computer* computer = builder.GetComputer();
    computer->Show();

    delete computer;
    return 0;
}

4. 适配器设计模式

适配器模式将一个类的接口转换成客户端期望的另一个接口，消除由于接口不兼容而导致的类无法一起工作的问题。

类适配器模式

#include <iostream>

class Source {
public:
    void method1() {
        std::cout << "This is original method..." << std::endl;
    }
};

class Targetable {
public:
    virtual void method1() = 0;
    virtual void method2() = 0;
    virtual ~Targetable() {}
};

class Adapter : public Source, public Targetable {
public:
    void method2() override {
        std::cout << "This is the targetable method..." << std::endl;
    }
};

int main() {
    Targetable* target = new Adapter();
    target->method1();
    target->method2();
    delete target;
    return 0;
}

对象适配器模式

#include <iostream>
#include <string>

using namespace std;

// 对象的适配器模式

// Source 类的定义
class Source {
public:
    void method1() {
        cout << "This is original method..." << endl;
    }
};

// Targetable 接口的定义
class Targetable {
public:
    virtual void method1() = 0; // 与原类中的方法相同
    virtual void method2() = 0; // 新类的方法
};

// Wrapper 类实现了 Targetable 接口
class Wrapper : public Targetable {
private:
    Source* source; // 持有 Source 类的实例
public:
    Wrapper(Source* s) : source(s) {}
    void method1() override {
        source->method1();
    }
    void method2() override {
        cout << "This is the targetable method..." << endl;
    }
};

int main() {
    Source* source = new Source();
    Targetable* targetable = new Wrapper(source);
    targetable->method1();
    targetable->method2();

    delete source;
    delete targetable;

    return 0;
}

接口的适配器模式

// 接口的适配器模式

#include <iostream>

using namespace std;

// 定义端口接口，提供通信服务
class Port {
public:
    virtual void SSH() = 0;
    virtual void NET() = 0;
    virtual void Tomcat() = 0;
    virtual void MySQL() = 0;
};

// 定义抽象类实现端口接口，但是什么事情都不做
class Wrapper : public Port {
public:
    void SSH() override {}
    void NET() override {}
    void Tomcat() override {}
    void MySQL() override {}
};

// 提供聊天服务，需要网络功能
class Chat : public Wrapper {
public:
    void NET() override {
        cout << "Hello World..." << endl;
    }
};

// 网站服务器，需要Tomcat容器，MySQL数据库，网络服务，远程服务
class Server : public Wrapper {
public:
    void SSH() override {
        cout << "Connect success..." << endl;
    }
    void NET() override {
        cout << "WWW..." << endl;
    }
    void Tomcat() override {
        cout << "Tomcat is running..." << endl;
    }
    void MySQL() override {
        cout << "MySQL is running..." << endl;
    }
};

int main() {
    Port* chatPort = new Chat();
    Port* serverPort = new Server();

    // 聊天服务
    chatPort->NET();

    // 服务器
    serverPort->SSH();
    serverPort->NET();
    serverPort->Tomcat();
    serverPort->MySQL();

    delete chatPort;
    delete serverPort;

    return 0;
}

5、Decorator Pattern（装饰模式）

装饰模式用于给一个对象增加一些新的功能，动态地为对象增加功能。

// 装饰模式

#include <iostream>

using namespace std;

// Shape 接口
class Shape {
public:
    virtual void draw() = 0;
};

// 实现接口的实体类 Rectangle
class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Shape: Rectangle..." << endl;
    }
};

// 实现接口的实体类 Circle
class Circle : public Shape {
public:
    void draw() override {
        cout << "Shape: Circle..." << endl;
    }
};

// 创建实现了 Shape 接口的抽象装饰类 ShapeDecorator
class ShapeDecorator : public Shape {
protected:
    Shape* decoratedShape;
public:
    ShapeDecorator(Shape* shape) : decoratedShape(shape) {}
    void draw() override {
        decoratedShape->draw();
    }
};

// 创建扩展自 ShapeDecorator 类的实体装饰类 RedShapeDecorator
class RedShapeDecorator : public ShapeDecorator {
public:
    RedShapeDecorator(Shape* shape) : ShapeDecorator(shape) {}
    void draw() override {
        decoratedShape->draw();
        setRedBorder();
    }
    void setRedBorder() {
        cout << "Border Color: Red" << endl;
    }
};

int main() {
    Shape* circle = new Circle();
    Shape* redCircle = new RedShapeDecorator(new Circle());
    Shape* redRectangle = new RedShapeDecorator(new Rectangle());

    cout << "Circle with normal border" << endl;
    circle->draw();

    cout << "\nCircle of red border" << endl;
    redCircle->draw();

    cout << "\nRectangle of red border" << endl;
    redRectangle->draw();

    delete circle;
    delete redCircle;
    delete redRectangle;

    return 0;
}

6、Strategy Pattern（策略模式）

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。

// 策略模式

#include <iostream>

using namespace std;

// 抽象算法的策略类 Strategy
class Strategy {
public:
    virtual  void AlgorithmInterface() = 0; // 算法方法
};

// 具体算法A
class ConcreteStrategyA : public Strategy {
public:
    void AlgorithmInterface() override {
        cout << "算法A的实现" << endl;
    }
};

// 具体算法B
class ConcreteStrategyB : public Strategy {
public:
    void AlgorithmInterface() override {
        cout << "算法B的实现" << endl;
    }
};

// 具体算法C
class ConcreteStrategyC : public Strategy {
public:
    void AlgorithmInterface() override {
        cout << "算法C的实现" << endl;
    }
};

// 上下文，维护一个对策略类对象的引用
class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* s) : strategy(s) {}
    void contextInterface() {
        strategy->AlgorithmInterface();
    }
};

int main() {
    Context* context;

    context = new Context(new ConcreteStrategyA());
    context->contextInterface();

    context = new Context(new ConcreteStrategyB());
    context->contextInterface();

    context = new Context(new ConcreteStrategyC());
    context->contextInterface();

    delete context;

    return 0;
}

7、Proxy Pattern（代理模式）

代理模式用于控制对原对象的引用，分为静态代理和动态代理。

// 代理模式

#include <iostream>

using namespace std;

// 服务接口
class IService {
public:
    virtual void service() = 0;
};

// 被代理类
class Service : public IService {
public:
    void service() override {
        cout << "被代理对象执行相关操作" << endl;
    }
};

// 代理类
class ProxyService : public IService {
private:
    IService* service;
public:
    ProxyService(IService* s) : service(s) {}
    void service() override {
        cout << "开始执行service()方法" << endl;
        service->service();
        cout << "service()方法执行完毕" << endl;
    }
};

int main() {
    IService* service = new Service();
    ProxyService* proxyService = new ProxyService(service);
    proxyService->service();

    delete service;
    delete proxyService;

    return 0;
}

8、Template Method Pattern（模板方法模式）

模板方法模式定义了一个算法的骨架，将一些步骤延迟到子类中实现，使得子类可以重新定义算法的步骤。

// 模板方法模式

#include <iostream>
#include <string>
#include <ctime>

using namespace std;

// 员工抽象类
class Worker {
protected:
    string name;
public:
    Worker(const string& n) : name(n) {}
    void workOneDay() {
        cout << "-----------------work start----------------" << endl;
        enterCompany();
        work();
        exitCompany();
        cout << "-----------------work end----------------" << endl;
    }
    virtual void work() = 0; // 工作抽象方法
    virtual bool isNeedPrintDate() {
        return false; // 钩子方法，默认不打印日期
    }
private:
    void enterCompany() {
        cout << name << "---进入公司" << endl;
    }
    void exitCompany() {
        if (isNeedPrintDate()) {
            time_t now = time(nullptr);
            cout << "---" << ctime(&now) << "--->" << endl;
        }
        cout << name << "---离开公司" << endl;
    }
};

// 测试人员类
class QAWorker : public Worker {
public:
    QAWorker(const string& n) : Worker(n) {}
    void work() override {
        cout << name << "---测试产品质量" << endl;
    }
};

// HR 类
class HRWorker : public Worker {
public:
    HRWorker(const string& n) : Worker(n) {}
    void work() override {
        cout << name << "---招聘新员工" << endl;
    }
};

// 程序猿类
class ITWorker : public Worker {
public:
    ITWorker(const string& n) : Worker(n) {}
    void work() override {
        cout << name << "---撰写代码" << endl;
    }
    bool isNeedPrintDate() override {
        return true; // 钩子方法，打印日期
    }
};

int main() {
    QAWorker* qaWorker = new QAWorker("测试人员");
    qaWorker->workOneDay();

    HRWorker* hrWorker = new HRWorker("莉莉姐");
    hrWorker->workOneDay();

    ITWorker* itWorker = new ITWorker("jingbin");
    itWorker->workOneDay();

    delete qaWorker;
    delete hrWorker;
    delete itWorker;

    return 0;
}

这些 C++ 代码可以帮助读者更好地理解设计模式及其在实际代码中的应用。