# 结构型设计模式

通常用来表示类与类之间的协作关系,用以创造出一个有更强大功能的组件.


![屏幕截图 2025-10-01 101234.png](/static/img/1486408bc95da05216749dca045239b6.%C3%A5%C2%B1%C2%8F%C3%A5%C2%B9%C2%95%C3%A6%C2%88%C2%AA%C3%A5%C2%9B%C2%BE%202025-10-01%20101234.webp)



## 适配器模式
在一些情况下,当进行软件开发协作时,或者我们在使用第三方库的内部类时,我们可能会察觉到相似的类,出现了不同的功能的情况,这时候,希望能够有一种统一的接口规范来规约这些类.在这种情况下,可以在一个类上方接入一个适配器,和不协调的类进行交互. 

一般来说,适配器会在内部获取到一个类的实例.


```cpp
#pragma once

#include <iostream>
#include <vector>

namespace Adapter {
	class TargetA {
	public:
		void func();
	};

	class TargetB {
	public:
		void F();
	};

	class TargetAdatper {
	public:
		virtual void doSomething() const = 0;
	};

	class TargetAAdapter : public TargetAdatper {
	public:
		TargetAAdapter(TargetA* a) : a_(a) {}
		void doSomething() const override {
			a_->func();
		}
	private:
		TargetA* a_;
	};

	class TargetBAdapter : public TargetAdatper {
	public:
		TargetBAdapter(TargetB* b) : b_(b) {}
		void doSomething() const override {
			b_->F();
		}
	private:
		TargetB* b_;
	}
}
```

UML设计如下

![屏幕截图 2025-10-01 102428.png](/static/img/f9043474db6225cd62f9cfac95d41246.image.webp)



## 桥接模式
用于表示两个类之间的关系,一个类可能是另一个类的一个部分(聚合),那么我们可以通过桥接的方式,在一个类中添加对另一个类的引用或者拷贝.

C++结构型设计模式

# 创造型设计模式

通常用于隐藏类的实现细节,或者提供便捷的类创造服务.



## 单例模式

在某些情况下,软件会遇到贯穿其生命周期始终的对象,这时候,我们需要通过合适的方法,去保证在每一个时刻,最多存在一个这个类的实例:


```cpp
#pragma once

#include <memory>
#include <vector>



namespace Singleton {
	class GameManager{
	private:
		GameManager() {}
		GameManager(const GameManager&) = delete;
		GameManager& operator=(const GameManager&) = delete;
	public:
		static ::std::shared_ptr<GameManager> getInstance()  {
			static ::std::shared_ptr<GameManager> instance(new GameManager());
			return instance;
		}

	}
}
```

## 原型模式
有时,我们希望某些类可以通过自身来构造新的类,所以我们以它为原型,创建一个新的类


```cpp
#pragma once

#include <memory>
#include <vector>

namespace CanCopy {
	struct copyable {
		virtual ::std::shared_ptr<copyable> clone() const = 0;
		virtual ~copyable() = default;
	};

	class Map : public copyable {
	public:
		virtual ::std::shared_ptr<copyable> clone() const override {
			return ::std::make_shared<Map>(*this);
		}
	};
}
```

## 工厂方法模式
对于一系列相同的类的创建,我们不希望在每一个地方显式的写出构造函数,而是希望将其委托给第三方来做,这样做的好处在于: 如果之后遇到修改类的构造函数的情况,我们可以只在Factory一个地方给出修改,而不用修改多处代码.


```cpp
#pragma once

#include <iostream>
#include <memory>

namespace Factory {
	class Product {

	};

	class ProductA : public Product {

	};

	class CreateProductFactory {
	public:
		virtual std::shared_ptr<Product> createProduct() = 0;
	};

	
	class CreateProductAFactory:public CreateProductFactory {
	public:
		virtual std::shared_ptr<Product> createProduct() override {
			return std::make_shared<ProductA>();
		}
	};
}
```
UML设计如下:



![屏幕截图 2025-09-30 213033.png](/static/img/871ef0ba0ed12bff4ee33217c01754a6.%C3%A5%C2%B1%C2%8F%C3%A5%C2%B9%C2%95%C3%A6%C2%88%C2%AA%C3%A5%C2%9B%C2%BE%202025-09-30%20213033.webp)

## 抽象工厂模式

类似于工厂方法模式,其实就是一个工厂生产一种对象变成一个工厂生产多种对象,类比于上面的话,相当于合并ProductAFactory和ProductBFactory,同时将这几个method抽象成接口给到CreateFactory

## 简单工厂模式

由于一个工厂能够生产的东西越来越多,给客户(包括程序员)带来了较大的理解负担,所以希望能够在Factory中增加一个"前台",这个前台获取用户的要求,然后通知工人生产对应的"产品".

## 建造者模式

在快速变化的系统中,如果我们预估,一个类如果经常会进行修改的话,那么经常修改构造函数是个比较危险的行为,因为一个好的系统应该对扩展开放,而对修改封闭. 为了能够解决这个问题,我们可以将类型的构造分离,每一步都是在对这个对象进行安装,最后形成一个整体.