本文共 3654 字，大约阅读时间需要 12 分钟。

结构型模式是软件设计中的一个重要概念，它通过将类或对象的组合成更大的结构，解决系统之间的接口不兼容或子系统耦合度过高的问题。常见的结构型模式包括适配器模式、桥接模式、装饰模式、外观模式、享元模式和代理模式等。下面将分别介绍每种模式的特点、实现方式以及适用场景。

1. 适配器模式 - Adapter Pattern

适配器模式的作用是将一个系统的接口转换成另一个系统可以使用的接口，从而使原本无法协作的类或组件能够正常工作。适配器类通常由两个角色组成：目标抽象类（Target）、适配器类（Adapter）和适配者类（Adaptee）。适配器通过继承或包装目标和适配者类，实现双方的接口转换。

示例代码

// Adapter.h#include "Target.h"#include "Adaptee.h"class Adapter : public Target {public:    Adapter(Adaptee *adaptee);    virtual ~Adapter();    virtual void request();private:    Adaptee *m_pAdaptee;};

// Adapter.cpp#include "Adapter.h"#include 
   
    Adapter::Adapter(Adaptee *adaptee) {    m_pAdaptee = adaptee;}Adapter::~Adapter() {}void Adapter::request() {    m_pAdaptee->specificRequest();}
   

适配器模式的适用场景包括：

• 当一个系统需要调用另一个系统的接口时，接口不兼容的情况。
• 当需要对现有的类进行功能扩展或调整时。

2. 桥接模式 - Bridge Pattern

桥接模式通过将抽象部分与实现部分分离，从而使两者可以独立变化。其核心思想是让抽象类与实现类之间 Metals形成弱耦合关系。

示例代码

// RefinedAbstraction.h#include "Abstraction.h"class RefinedAbstraction : public Abstraction {public:    RefinedAbstraction();    RefinedAbstraction(Implementor *imp);    virtual ~RefinedAbstraction();    virtual void operation();};

// RefinedAbstraction.cpp#include "RefinedAbstraction.h"#include 
   
    using namespace std;RefinedAbstraction::RefinedAbstraction() {}RefinedAbstraction::RefinedAbstraction(Implementor *imp) : Abstraction(imp) {}RefinedAbstraction::~RefinedAbstraction() {}void RefinedAbstraction::operation() {    cout << "do something else, and then ";    m_pImp->operationImp();}
   

桥接模式的适用场景包括：

• 当一个系统需要扩展某个组件的功能，而不引起 componente其它部分的重构时。
• 当需要在已有的系统基础上增加多个不同的实现方式时。

3. 装饰模式 - Decorator Pattern

装饰模式允许在 runtime阶段对一个对象的功能进行扩展，而无需创建新的子类。其核心思想是通过组合关联关系而非继承关系来实现功能的动态扩展。

示例代码

// ConcreteDecoratorA.h#include "Decorator.h"#include "Component.h"class ConcreteDecoratorA : public Decorator {public:    ConcreteDecoratorA(Component *pcmp);    virtual ~ConcreteDecoratorA();    void addBehavior();    virtual void operation();};

装饰模式的适用场景包括：

• 当需要在已有组件基础上动态地增加功能时。
• 当功能需求相对稳定但具体实现需要频繁变化时。

4. 外观模式 - Facade Pattern

外观模式为子系统提供了一个统一的接口，使外部系统无需关心子系统的内部复杂性。通过引入一个外观角色（Facade），不同子系统之间的耦合度得到了降低。

示例代码

// Facade.h#ifndef __FACADE_H__#define __FACADE_H__#include "SystemC.h"#include "SystemA.h"#include "SystemB.h"class Facade {public:    Facade();    virtual ~Facade();    void wrapOpration();private:    SystemC *m_SystemC;    SystemA *m_SystemA;    SystemB *m_SystemB;};#endif

外观模式的适用场景包括：

• 当一个大型系统的子系统之间相互耦合，导致难以扩展和维护时。
• 当需要为复杂的系统提供简单的入口时。

5. 享元模式 - Flyweight Pattern

享元模式通过共享对象的状态，减少对象的数量，以提高系统的性能。这适用于需要大量对象复用的场景，如游戏中的粒子效果或Web应用中的会话管理。

示例代码

// FlyweightFactory.cpp#include "FlyweightFactory.h"#include "ConcreteFlyweight.h"using namespace std;FlyweightFactory::FlyweightFactory() {}FlyweightFactory::~FlyweightFactory() {}Flyweight* FlyweightFactory::getFlyweight(string str) {    map
   
        ::iterator itr = m_mpFlyweight.find(str);    if (itr == m_mpFlyweight.end()) {        Flyweight *fw = new ConcreteFlyweight(str);        m_mpFlyweight.insert(make_pair(str, fw));        return fw;    } else {        cout << "Already in the pool, use the existing one: ";        return itr->second;    }}
   

享元模式的适用场景包括：

• 当系统需要支持大量细粒度的对象时。
• 当对象的状态可以共享且不因状态不同而产生新的对象时。

6. 代理模式 - Proxy Pattern

代理模式通过引入一个间接对象（Proxy），在不直接访问真实对象的情况下，实现对真实对象的操作。常用于需要对真实对象进行远程操作、安全控制或日志记录等场景。

示例代码

// Proxy.h#ifndef __PROXY_H__#define __PROXY_H__#include "RealSubject.h"#include "Subject.h"class Proxy : public Subject {public:    Proxy();    virtual ~Proxy();    void request();private:    void preRequest();    void afterRequest();    RealSubject *m_pRealSubject;};#endif

代理模式的适用场景包括：

• 当需要对真实对象进行远程访问时。
• 当需要对真实对象施加安全控制或日志记录时。

以上是几种常见结构型模式的简要介绍。通过合理地使用这些模式，可以显著地提高系统的可维护性和扩展性。在实际应用中，可以根据具体需求选择适合的模式，并灵活组合多种模式，以构建出高效、可靠的系统架构。