C++在Linux中如何实现设计模式

在Linux环境下用C++来实现设计模式，这事儿其实没那么玄乎，只要按部就班走几步就能上手。简单来说，可以分成这么几个环节：

1. 先挑个合适的模式。设计模式三大类——创建型、结构型、行为型——每种底下都有不少选项，选哪个取决于你当前要解决什么问题。

2. 理解透它的原理。别急着写代码，先把模式的目的、适用场景、核心概念吃透，不然容易写成“四不像”。

3. 用C++把代码写出来。注意清晰、简洁，别堆砌，遵循基本的好习惯。

4. 编译跑一跑。Linux上g++是标配，编完之后测试一下，看行为对不对。

5. 调试和维护。只要上了生产环境，迟早得回头修修补补，这是常态。

下面拿三个常见模式举个例子，代码都是能直接编译运行的片段，方便你感受一下C++里它们长什么样。

单例模式（Singleton Pattern）

单例模式说白了就是“一个类只允许有一个实例”，并且提供一个全局访问点。这里用到了互斥锁来保证线程安全——多线程环境下这点很重要。

#include #include class Singleton {private:static Singleton* instance;static std::mutex mtx;Singleton() {} // 私有构造函数public:static Singleton* getInstance() {std::lock_guard lock(mtx);if (instance == nullptr) {instance = new Singleton();}return instance;}void showMessage() {std::cout << "Hello, I am a singleton!" << std::endl;}};Singleton* Singleton::instance = nullptr;std::mutex Singleton::mtx;int main() {Singleton* s = Singleton::getInstance();s->showMessage();return 0;}

工厂模式（Factory Pattern）

工厂模式帮你把“创建对象”这件事和“具体使用哪个类”解耦。调用方只管告诉工厂要什么类型的产品，工厂来决定实例化哪个具体类。这里用了智能指针管理内存，省心不少。

#include #include // 抽象产品类class Product {public:virtual void use() = 0;virtual ~Product() {}};// 具体产品类Aclass ConcreteProductA : public Product {public:void use() override {std::cout << "Using ConcreteProductA" << std::endl;}};// 具体产品类Bclass ConcreteProductB : public Product {public:void use() override {std::cout << "Using ConcreteProductB" << std::endl;}};// 工厂类class Factory {public:static std::unique_ptr createProduct(const std::string& type) {if (type == "A") {return std::make_unique();} else if (type == "B") {return std::make_unique();}return nullptr;}};int main() {auto productA = Factory::createProduct("A");if (productA) {productA->use();}auto productB = Factory::createProduct("B");if (productB) {productB->use();}return 0;}

观察者模式（Observer Pattern）

观察者模式处理的是“一对多”的依赖关系：一个主题对象状态发生变化，所有依赖它的观察者都会收到通知并自动更新。这个模式尽管用，但要注意内存管理，上例中观察者是用原始指针管理的，实际项目里建议用智能指针或谨慎控制生命周期。

#include #include #include // 观察者接口class Observer {public:virtual void update(const std::string& message) = 0;virtual ~Observer() {}};// 具体观察者class ConcreteObserver : public Observer {private:std::string name;public:ConcreteObserver(const std::string& name) : name(name) {}void update(const std::string& message) override {std::cout << name << " received message: " << message << std::endl;}};// 主题接口class Subject {private:std::vector observers;public:void attach(Observer* observer) {observers.push_back(observer);}void detach(Observer* observer) {observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());}void notify(const std::string& message) {for (Observer* observer : observers) {observer->update(message);}}};int main() {Subject subject;ConcreteObserver observer1("Observer1");ConcreteObserver observer2("Observer2");subject.attach(&observer1);subject.attach(&observer2);subject.notify("Hello Observers!");subject.detach(&observer1);subject.notify("Hello again!");return 0;}

这三个例子只是抛砖引玉。真正拿到项目里，你多半要根据具体场景做调整——比如单例的懒加载策略、工厂的扩展方式、观察者的消息过滤等。但基本原则不变：理解核心思想，再动手写代码，这样在Linux + C++的实战里才能游刃有余。