以下是单例模式和观察者模式的介绍及应用场景：
单例模式
- 定义：保证一个类仅有一个实例，并提供一个全局访问点。
- 实现方式：私有化构造函数，防止外部实例化；提供一个静态成员函数来获取唯一实例。
- 应用场景：在系统中，当某个资源需要全局唯一访问，如数据库连接池、文件系统操作对象、系统配置对象等，可使用单例模式。以数据库连接池为例，多个模块可能都需要访问数据库，使用单例模式可确保所有模块使用同一个连接池，避免资源浪费和连接管理的混乱。
观察者模式
- 定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
- 实现方式：通常有主题（被观察对象）和观察者两个角色。主题维护一个观察者列表，当主题状态改变时，遍历列表通知所有观察者。
- 应用场景：广泛应用于事件处理系统、界面更新、消息通知等场景。如在图形界面应用中，当用户操作界面元素（如按钮点击）时，多个相关的组件（如文本框、菜单等）可能需要根据这个操作进行更新，就可以使用观察者模式。当按钮状态改变（被点击）时，作为主题通知所有注册的观察者（相关组件）进行相应的更新操作。以下是用C++分别实现单例模式和观察者模式的代码示例：
单例模式（懒汉式单例）
cpp
#include <iostream>
#include <mutex>
using namespace std;
class Singleton {
private:
static Singleton* instance;
static mutex mtx;
Singleton() {}
public:
static Singleton* getInstance() {
if (instance == nullptr) {
lock_guard<mutex> lock(mtx);
if (instance == nullptr) {
instance = new Singleton();
}
}
return instance;
}
void showMessage() {
cout << "This is a singleton instance." << endl;
}
};
Singleton* Singleton::instance = nullptr;
mutex Singleton::mtx;
单例模式使用示例
cpp
int main() {
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance();
if (s1 == s2) {
cout << "Both are the same instance." << endl;
}
s1->showMessage();
return 0;
}
观察者模式
cpp
#include <iostream>
#include <vector>
using namespace std;
// 观察者接口
class Observer {
public:
virtual void update() = 0;
virtual ~Observer() {}
};
// 主题接口
class Subject {
public:
virtual void attach(Observer* observer) = 0;
virtual void detach(Observer* observer) = 0;
virtual void notify() = 0;
virtual ~Subject() {}
};
// 具体主题
class ConcreteSubject : public Subject {
private:
vector<Observer*> observers;
int state;
public:
void attach(Observer* observer) override {
observers.push_back(observer);
}
void detach(Observer* observer) override {
for (auto it = observers.begin(); it != observers.end(); ++it) {
if (*it == observer) {
observers.erase(it);
break;
}
}
}
void notify() override {
for (Observer* observer : observers) {
observer->update();
}
}
int getState() const {
return state;
}
void setState(int newState) {
state = newState;
notify();
}
};
// 具体观察者
class ConcreteObserver : public Observer {
private:
string name;
Subject* subject;
public:
ConcreteObserver(const string& n, Subject* sub) : name(n), subject(sub) {}
void update() override {
cout << "Observer " << name << " updated. New state: " << subject->getState() << endl;
}
};
观察者模式使用示例
cpp
int main() {
ConcreteSubject subject;
ConcreteObserver observer1("Observer1", &subject);
ConcreteObserver observer2("Observer2", &subject);
subject.attach(&observer1);
subject.attach(&observer2);
subject.setState(10);
subject.detach(&observer1);
subject.setState(20);
return 0;
}
上述代码中，单例模式实现了懒汉式的单例，通过双重检查锁定确保线程安全地获取唯一实例。观察者模式定义了主题和观察者的接口，具体主题维护观察者列表并在状态变化时通知观察者，具体观察者实现了更新方法以响应主题的变化。
