在Linux环境下使用C++进行编程时，应用设计模式可以显著优化代码结构，提高代码的可维护性和可扩展性。以下是一些常用的设计模式及其在C++中的实现示例：
1. 单例模式（Singleton Pattern）
单例模式确保一个类只有一个实例，并提供一个全局访问点。
#include
#include
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 instance;
static std::once_flag initFlag;
};
std::unique_ptr Singleton::instance;
std::once_flag Singleton::initFlag;
int main() {
Singleton& s = Singleton::getInstance();
return 0;
}
2. 工厂模式（Factory Pattern）
工厂模式提供了一种创建对象的方式，而无需指定具体的类。
#include
#include
class Product {
public:
virtual ~Product() {}
virtual void use() = 0;
};
class ConcreteProductA : public Product {
public:
void use() override {
std::cout << "Using ConcreteProductA" << std class="hljs-keyword">class ConcreteProductB : public Product {
public:
void use() override {
std::cout << "Using ConcreteProductB" << std class="hljs-keyword">class Creator {
public:
virtual ~Creator() {}
virtual std::unique_ptr factoryMethod() = 0;
};
class ConcreteCreatorA : public Creator {
public:
std::unique_ptr factoryMethod() override {
return std::make_unique();
}
};
class ConcreteCreatorB : public Creator {
public:
std::unique_ptr factoryMethod() override {
return std::make_unique();
}
};
int main() {
std::unique_ptr creator = std::make_unique();
std::unique_ptr product = creator->factoryMethod();
product->use();
return 0;
}
3. 观察者模式（Observer Pattern）
观察者模式定义了对象间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会收到通知并自动更新。
#include
#include
#include
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 observers;
};
class ConcreteObserver : public Observer {
public:
ConcreteObserver(const std::string& name) : name(name) {}
void update(const std::string& message) override {
std::cout << name class="hljs-string">" received message: " << message class="hljs-keyword">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
#include
class Strategy {
public:
virtual ~Strategy() {}
virtual void execute() = 0;
};
class ConcreteStrategyA : public Strategy {
public:
void execute() override {
std::cout << "Executing strategy A" << std class="hljs-keyword">class ConcreteStrategyB : public Strategy {
public:
void execute() override {
std::cout << "Executing strategy B" << std class="hljs-keyword">class Context {
public:
Context(std::unique_ptr strategy) : strategy(std::move(strategy)) {}
void setStrategy(std::unique_ptr newStrategy) {
strategy = std::move(newStrategy);
}
void executeStrategy() {
strategy->execute();
}
private:
std::unique_ptr strategy;
};
int main() {
auto strategyA = std::make_unique();
Context context(std::move(strategyA));
context.executeStrategy();
auto strategyB = std::make_unique();
context.setStrategy(std::move(strategyB));
context.executeStrategy();
return 0;
}
5. 模板方法模式（Template Method Pattern）
模板方法模式定义了一个算法的骨架，但将一些步骤延迟到子类中实现。
#include
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 class="hljs-keyword">class ConcreteClassA : public AbstractClass {
protected:
void step1() override {
std::cout << "ConcreteClassA: Step 1" << std class="hljs-function">void step2() override {
std::cout << "ConcreteClassA: Step 2" << std class="hljs-keyword">class ConcreteClassB : public AbstractClass {
protected:
void step1() override {
std::cout << "ConcreteClassB: Step 1" << std class="hljs-function">void step2() override {
std::cout << "ConcreteClassB: Step 2" << std class="hljs-function">void step3() override {
std::cout << "ConcreteClassB: Step 3" << std class="hljs-function">int main() {
ConcreteClassA concreteClassA;
concreteClassA.templateMethod();
ConcreteClassB concreteClassB;
concreteClassB.templateMethod();
return 0;
}
通过合理使用这些设计模式，可以使代码更加模块化、可维护和可扩展。在实际项目中，应根据具体需求选择合适的设计模式。