一、创建型模式
创建型模式是指将对象的创建与使用分离，让系统更加灵活地创建对象。常见的创建型模式包括：
1. 工厂模式
工厂模式是一种高级抽象的创建型模式，它利用工厂类（Factory）负责创建其他对象。工厂模式可以分为简单工厂模式、工厂方法模式和抽象工厂模式。以下是一个简单工厂模式的代码示例：
class Animal{
public:
virtual void speak() = 0;
};
class Dog : public Animal{
public:
void speak() override{
std::cout << "汪汪汪" << std::endl;
}
};
class Cat : public Animal{
public:
void speak() override{
std::cout << "喵喵喵" <speak();
}
if(a2 != nullptr){
a2->speak();
}
delete a1;
delete a2;
return 0;
}
2. 单例模式
单例模式是一种只允许一个对象实例的创建型模式，它常用于系统中全局状态的管理。以下是一个单例模式的代码示例：
class Singleton{
private:
Singleton(){}
static Singleton* instance;
public:
static Singleton* getInstance(){
if(instance == nullptr){
instance = new Singleton();
}
return instance;
}
};
Singleton* Singleton::instance = nullptr;
int main(){
Singleton* s1 = Singleton::getInstance();
Singleton* s2 = Singleton::getInstance();
std::cout << (s1 == s2) << std::endl; //输出1
return 0;
}
二、结构型模式
结构型模式是指如何将类和对象按照某种布局组成更大的结构。常见的结构型模式包括：
1. 适配器模式
适配器模式是一种将两个不兼容的接口互相转换的结构型模式，它常用于将老系统中的接口转换为新系统中的接口。以下是一个类适配器模式的代码示例：
class Target{
public:
virtual void request() = 0;
};
class Adaptee{
public:
void specificRequest(){
std::cout << "适配器模式示例" <specificRequest();
}
};
int main(){
Adaptee* a = new Adaptee();
Target* t = new Adapter(a);
t->request();
delete a;
delete t;
return 0;
}
2. 装饰器模式
装饰器模式是一种动态地给对象添加功能的结构型模式，它常用于不想增加子类的情况下，对对象的功能进行扩展。以下是一个装饰器模式的代码示例：
class Component{
public:
virtual void operation() = 0;
};
class ConcreteComponent : public Component{
public:
void operation() override{
std::cout << "装饰器模式示例" <operation();
}
}
};
class ConcreteDecorator : public Decorator{
public:
ConcreteDecorator(Component* c) : Decorator(c){}
void operation() override{
Decorator::operation();
std::cout << "被装饰" <operation();
Component* c2 = new ConcreteDecorator(c1);
c2->operation();
delete c1;
delete c2;
return 0;
}
三、行为型模式
行为型模式是指对象之间的通信方式及其分配职责的方式，常见的行为型模式包括：
1. 观察者模式
观察者模式是一种对象间的一对多依赖关系，当一个对象的状态发生改变时，它的所有依赖者都会收到通知。以下是一个观察者模式的代码示例：
class Subject;
class Observer{
public:
virtual void update(Subject* s) = 0;
};
class Subject{
private:
std::vector observers;
public:
void attach(Observer* o){
observers.push_back(o);
}
void detach(Observer* o){
auto iter = std::find(observers.begin(), observers.end(), o);
if(iter != observers.end()){
observers.erase(iter);
}
}
void notify(){
for(auto obs: observers){
obs->update(this);
}
}
virtual int getState() = 0;
virtual void setState(int state) = 0;
};
class ConcreteSubject : public Subject{
private:
int state;
public:
int getState() override{
return state;
}
void setState(int s) override{
state = s;
notify();
}
};
class ConcreteObserver : public Observer{
public:
void update(Subject* s) override{
std::cout << "观察者收到通知，当前状态为" <getState() <attach(o1);
s->attach(o2);
s->setState(1);
s->detach(o1);
s->setState(2);
delete s;
delete o1;
delete o2;
return 0;
}
2. 策略模式
策略模式是一种将不同算法封装起来，使它们可以相互替换的行为型模式，它常用于将算法的变化独立于使用算法的客户端。以下是一个策略模式的代码示例：
class Strategy{
public:
virtual int doOperation(int a, int b) = 0;
};
class AddStrategy : public Strategy{
public:
int doOperation(int a, int b) override{
return a + b;
}
};
class SubStrategy : public Strategy{
public:
int doOperation(int a, int b) override{
return a - b;
}
};
class Context{
private:
Strategy* strategy;
public:
void setStrategy(Strategy* s){
strategy = s;
}
int executeStrategy(int a, int b){
return strategy->doOperation(a, b);
}
};
int main(){
Context* c = new Context();
c->setStrategy(new AddStrategy());
std::cout <executeStrategy(1, 2) <setStrategy(new SubStrategy());
std::cout <executeStrategy(3, 2) << std::endl;
delete c;
return 0;
}