Linux C++下如何使用设计模式优化代码结构

在Linux环境下使用C++进行编程时，应用设计模式可以显著优化代码结构，提高代码的可维护性和可扩展性。以下是一些常用的设计模式及其在C++中的实现示例：

1. 单例模式（Singleton Pattern）

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

#include <iostream>
#include <mutex>

class Singleton {
public:
    static Singleton& getInstance() {
        std::call_once(initFlag, &Singleton::initSingleton);
        return *instance;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {}
    static void initSingleton() {
        instance = new Singleton();
    }

    static std::unique_ptr<Singleton> instance;
    static std::once_flag initFlag;
};

std::unique_ptr<Singleton> Singleton::instance;
std::once_flag Singleton::initFlag;

int main() {
    Singleton& s = Singleton::getInstance();
    return 0;
}

2. 工厂模式（Factory Pattern）

工厂模式提供了一种创建对象的方式，而无需指定具体的类。

#include <iostream>
#include <memory>

class Product {
public:
    virtual ~Product() {}
    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA" << std::endl;
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB" << std::endl;
    }
};

class Creator {
public:
    virtual ~Creator() {}
    virtual std::unique_ptr<Product> factoryMethod() = 0;
};

class ConcreteCreatorA : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() override {
        return std::make_unique<ConcreteProductA>();
    }
};

class ConcreteCreatorB : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    std::unique_ptr<Creator> creator = std::make_unique<ConcreteCreatorA>();
    std::unique_ptr<Product> product = creator->factoryMethod();
    product->use();
    return 0;
}

3. 观察者模式（Observer Pattern）

观察者模式定义了对象间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会收到通知并自动更新。

#include <iostream>
#include <vector>
#include <algorithm>

class Observer {
public:
    virtual ~Observer() {}
    virtual void update(const std::string& message) = 0;
};

class Subject {
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);
        }
    }

private:
    std::vector<Observer*> observers;
};

class ConcreteObserver : public Observer {
public:
    ConcreteObserver(const std::string& name) : name(name) {}

    void update(const std::string& message) override {
        std::cout << name << " received message: " << message << std::endl;
    }

private:
    std::string name;
};

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

4. 策略模式（Strategy Pattern）

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

#include <iostream>
#include <memory>

class Strategy {
public:
    virtual ~Strategy() {}
    virtual void execute() = 0;
};

class ConcreteStrategyA : public Strategy {
public:
    void execute() override {
        std::cout << "Executing strategy A" << std::endl;
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        std::cout << "Executing strategy B" << std::endl;
    }
};

class Context {
public:
    Context(std::unique_ptr<Strategy> strategy) : strategy(std::move(strategy)) {}

    void setStrategy(std::unique_ptr<Strategy> newStrategy) {
        strategy = std::move(newStrategy);
    }

    void executeStrategy() {
        strategy->execute();
    }

private:
    std::unique_ptr<Strategy> strategy;
};

int main() {
    auto strategyA = std::make_unique<ConcreteStrategyA>();
    Context context(std::move(strategyA));

    context.executeStrategy();

    auto strategyB = std::make_unique<ConcreteStrategyB>();
    context.setStrategy(std::move(strategyB));

    context.executeStrategy();

    return 0;
}

5. 模板方法模式（Template Method Pattern）

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

#include <iostream>

class AbstractClass {
public:
    void templateMethod() {
        step1();
        step2();
        step3();
    }

protected:
    virtual void step1() = 0;
    virtual void step2() = 0;
    virtual void step3() {
        std::cout << "Default implementation of step3" << std::endl;
    }
};

class ConcreteClassA : public AbstractClass {
protected:
    void step1() override {
        std::cout << "ConcreteClassA: Step 1" << std::endl;
    }

    void step2() override {
        std::cout << "ConcreteClassA: Step 2" << std::endl;
    }
};

class ConcreteClassB : public AbstractClass {
protected:
    void step1() override {
        std::cout << "ConcreteClassB: Step 1" << std::endl;
    }

    void step2() override {
        std::cout << "ConcreteClassB: Step 2" << std::endl;
    }

    void step3() override {
        std::cout << "ConcreteClassB: Step 3" << std::endl;
    }
};

int main() {
    ConcreteClassA concreteClassA;
    concreteClassA.templateMethod();

    ConcreteClassB concreteClassB;
    concreteClassB.templateMethod();

    return 0;
}

通过合理使用这些设计模式，可以使代码更加模块化、可维护和可扩展。在实际项目中，应根据具体需求选择合适的设计模式。