突破编程_C++_设计模式（适配器模式）

1 适配器模式的基本概念

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许一个类的接口与另一个类的接口不兼容时，仍然能够协同工作。适配器模式的主要目的是通过提供一个中间层来转换接口，使得原本不兼容的接口能够协同工作。

在 C++ 中，适配器模式通常通过继承或组合来实现。具体来说，适配器模式包含以下三个角色：

• 目标接口（Target Interface）：定义了一个客户端所期望的接口。客户端代码通过目标接口与适配器进行交互。
• 适配者（Adaptee）：拥有一个或多个特定的接口，这些接口可能与目标接口不兼容。适配者是实现了具体功能的类，但其接口可能不符合客户端的需求。
• 适配器（Adapter）：适配器类实现了目标接口，并在其内部使用适配者来实现目标接口中的方法。适配器将适配者的接口转换为客户端所期望的接口，从而实现了接口的兼容。

适配器模式可以分为两种类型：类适配器（Class Adapter）和对象适配器（Object Adapter）。

• 类适配器：通过多重继承来实现。适配器类继承自目标接口和适配者类，从而在适配器类中实现目标接口的方法，并调用适配者类中的相应方法。这种方式的缺点是可能违反里氏替换原则（Liskov Substitution Principle），即子类必须能够替换其父类。
• 对象适配器：通过组合来实现。适配器类持有一个适配者对象的引用，并在实现目标接口的方法时，通过调用适配者对象的方法来完成功能。这种方式更符合面向对象的设计原则，因为适配器类与适配者类之间是通过组合关系而不是继承关系来实现的。

2 适配器模式的实现步骤

实现C++中的适配器模式通常涉及以下几个步骤：

（1）定义目标接口： 首先，需要定义一个目标接口，这个接口定义了客户端代码所期望的功能。

（2）定义适配者类： 接着，定义一个或多个适配者类，这些类拥有具体的功能实现，但其接口可能与目标接口不兼容。

（3）创建适配器类： 创建一个适配器类，该类实现了目标接口，并在其内部使用适配者来实现目标接口中的方法。适配器类可以通过继承或组合的方式来实现对适配者类的使用。

（4）在适配器中实现目标接口： 在适配器类中，实现目标接口的所有方法。在每个方法的实现中，调用适配者类的相应方法来完成实际的功能。

（5）客户端使用适配器： 最后，客户端代码通过目标接口与适配器进行交互，而不需要直接与适配者类交互。

下面是一个简单的适配器模式实现示例：

#include <iostream>  

// 目标接口  
class Target 
{
public:
	virtual void request() = 0;
	virtual ~Target() = default; // 虚析构函数以确保多态性  
};

// 适配者类  
class Adaptee 
{
public:
	void specificRequest() {
		// 适配者类的具体实现  
		std::cout << "Adaptee::specificRequest()" << std::endl;
	}
};

// 适配器类  
class Adapter : public Target 
{
public:
	Adapter() : adaptee(std::make_unique<Adaptee>()) {} // 在构造时初始化适配者  

	// 实现目标接口的方法  
	void request() override {
		// 在适配器中调用适配者的方法  
		adaptee->specificRequest();
	}

private:
	std::unique_ptr<Adaptee> adaptee; // 使用智能指针持有适配者对象  
};

// 客户端代码  
int main() 
{
	// 创建适配器对象，适配者对象将由智能指针自动管理  
	std::unique_ptr<Target> target = std::make_unique<Adapter>();

	// 客户端通过目标接口与适配器交互  
	target->request();

	// 当 target 超出作用域时，其析构函数将被调用，  
	// 进而调用 Adapter 的析构函数，最终释放 Adaptee 的内存。  

	return 0;
}

上面代码的输出为：

Adaptee::specificRequest()

在这个示例中，Target 是目标接口，Adaptee 是适配者类，Adapter 是适配器类。客户端代码通过 Target 接口与 Adapter 进行交互，而 Adapter 内部使用 Adaptee 来实现具体的功能。这样就实现了接口的适配，使得原本不兼容的接口能够协同工作。

3 适配器模式的应用场景

C++适配器模式的应用场景主要涉及以下几个方面：

（1）系统集成： 当两个系统或组件的接口不兼容，但是需要将它们集成在一起时，适配器模式非常有用。可以创建一个适配器，使一个系统的接口与另一个系统的接口兼容，从而实现两个系统的无缝集成。

（2）类库迁移： 当需要将一个类库迁移到另一个不兼容的类库中时，适配器模式可以帮助你实现这一目标。可以创建一个适配器类，它实现了新类库的接口，但内部使用旧类库的功能。

（3）代码重构： 在重构现有代码时，如果新的接口与旧的接口不兼容，可以使用适配器模式来逐步过渡。这样就可以在不修改现有代码的情况下，逐步采用新的接口。

（4）遗留代码集成： 在软件开发中，经常需要集成遗留代码（legacy code）。这些代码可能具有不兼容的接口，此时适配器模式可以帮助你将这些遗留代码与新的系统或组件集成。

（5）接口标准化： 当需要将多个不同的接口标准化为统一的接口时，可以使用适配器模式。这样就可以创建一个适配器类，它实现了标准接口，但内部可以适配多个不同的接口。

（6）扩展功能： 在不改变现有类结构的情况下，通过适配器模式可以为类添加新的功能。这有助于保持代码的模块化和可扩展性。

总体而言，C++ 适配器模式在解决接口不兼容问题、实现系统集成、代码重构和遗留代码集成等方面具有广泛的应用场景。它提高了代码的灵活性、可复用性和可维护性。

3.1 适配器模式在系统集成中的典型应用

当涉及到系统集成时，适配器模式可以帮助解决不同系统间接口不兼容的问题。以下是一个简化的代码样例，展示了如何使用适配器模式将两个不兼容的系统集成在一起：

假设有两个系统：SystemA 和 SystemB。SystemA 有一个 RequestInterface 接口，而 SystemB 有一个 SpecificRequestInterface 接口。这两个接口不兼容，但我们希望将 SystemB 集成到 SystemA 中。

首先，定义 SystemA 的接口：

// SystemA 的接口  
class RequestInterface 
{
public:
	virtual void performRequest() = 0;
	virtual ~RequestInterface() = default;
};

然后，定义 SystemB 的接口：

// SystemB 的接口  
class SpecificRequestInterface 
{
public:
	virtual void specificRequest() = 0;
	virtual ~SpecificRequestInterface() = default;
};

现在，实现一个 SpecificRequestInterface 的 SystemB 类：

// SystemB 的实现  
class SystemB : public SpecificRequestInterface 
{
public:
	void specificRequest() override {
		// SystemB 的具体实现  
		std::cout << "SystemB performing specific request." << std::endl;
	}
};

接下来，创建一个适配器类 SystemBAdapter，它实现了 RequestInterface，但内部使用 SystemB 的 SpecificRequestInterface：

// 适配器类，使 SystemB 兼容于 SystemA 的接口  
class SystemBAdapter : public RequestInterface 
{
public:
	SystemBAdapter() : systemB(std::make_unique<SystemB>()) {}

	void performRequest() override {
		// 在适配器中调用 SystemB 的具体方法  
		systemB->specificRequest();
	}

private:
	std::unique_ptr<SpecificRequestInterface> systemB;
};

最后，在客户端代码中，可以像使用 SystemA 的接口一样使用 SystemB：

// 客户端代码  
int main() 
{
	// 创建 SystemA 的请求对象，实际上是一个适配器对象  
	std::unique_ptr<RequestInterface> request = std::make_unique<SystemBAdapter>();

	// 客户端代码调用 SystemA 的接口  
	request->performRequest();

	return 0;
}

在这个样例中，SystemBAdapter 是一个适配器，它使得 SystemA 能够通过 RequestInterface 接口与 SystemB 交互，尽管它们的原始接口不兼容。使用这种方式，可以很容易地将 SystemB 集成到 SystemA 中，而无需修改任何一方的原始代码。这就是适配器模式在系统集成中的一个典型应用。

3.2 适配器模式在接口标准化中的典型应用

在接口标准化的场景中，适配器模式允许开发者定义一个统一的接口，并将多个不兼容的接口适配到这个标准接口上。这样，客户端代码就可以通过这个统一的接口与不同的系统进行交互，而无需关心这些系统背后的具体实现。

下面是一个简单的代码样例，展示了如何将两个不同的接口适配到一个统一的接口上。

首先，定义一个标准接口 StandardInterface：

// 标准接口  
class StandardInterface 
{
public:
	virtual void performAction() = 0;
	virtual ~StandardInterface() = default;
};

接着，定义两个不兼容的接口 InterfaceA 和 InterfaceB：

// 接口A  
class InterfaceA 
{
public:
	virtual void doActionA() = 0;
	virtual ~InterfaceA() = default;
};

// 接口B  
class InterfaceB 
{
public:
	virtual void doActionB() = 0;
	virtual ~InterfaceB() = default;
};

现在，分别实现 InterfaceA 和 InterfaceB 的类 ClassA 和 ClassB：

// 实现接口A的类  
class ClassA : public InterfaceA 
{
public:
	void doActionA() override {
		// 实现接口A的具体功能  
		std::cout << "Action A performed by ClassA." << std::endl;
	}
};

// 实现接口B的类  
class ClassB : public InterfaceB 
{
public:
	void doActionB() override {
		// 实现接口B的具体功能  
		std::cout << "Action B performed by ClassB." << std::endl;
	}
};

然后，需要创建适配器类来将 InterfaceA 和 InterfaceB 适配到 StandardInterface。这里，将为 InterfaceA 和 InterfaceB 分别创建适配器：

// 适配器A，将InterfaceA适配到StandardInterface  
class AdapterA : public StandardInterface 
{
public:
	AdapterA(std::shared_ptr<InterfaceA> a) : interfaceA(a) {}

	void performAction() override {
		// 调用InterfaceA的方法  
		interfaceA->doActionA();
	}

private:
	std::shared_ptr<InterfaceA> interfaceA;
};

// 适配器B，将InterfaceB适配到StandardInterface  
class AdapterB : public StandardInterface 
{
public:
	AdapterB(std::shared_ptr<InterfaceB> b) : interfaceB(b) {}

	void performAction() override {
		// 调用InterfaceB的方法  
		interfaceB->doActionB();
	}

private:
	std::shared_ptr<InterfaceB> interfaceB;
};

最后，客户端代码可以通过 StandardInterface 来调用不同的功能，而无需关心具体实现：

// 客户端代码  
int main() 
{
	// 创建实现InterfaceA和InterfaceB的对象  
	std::shared_ptr<InterfaceA> classA = std::make_shared<ClassA>();
	std::shared_ptr<InterfaceB> classB = std::make_shared<ClassB>();

	// 创建适配器对象  
	std::unique_ptr<StandardInterface> adapterA = std::make_unique<AdapterA>(classA);
	std::unique_ptr<StandardInterface> adapterB = std::make_unique<AdapterB>(classB);

	// 通过标准接口调用功能  
	adapterA->performAction(); // 输出 "Action A performed by ClassA."  
	adapterB->performAction(); // 输出 "Action B performed by ClassB."  

	return 0;
}

在上面代码中，定义了一个 StandardInterface，并创建了两个适配器 AdapterA 和 AdapterB，分别将 InterfaceA 和 InterfaceB 适配到这个标准接口上。客户端代码通过 StandardInterface 的 performAction 方法调用功能，而适配器内部会调用相应的 doActionA 或 doActionB 方法。这样就实现了接口的标准化，客户端代码可以无差别地与不同的系统交互。

4 适配器模式的优点与缺点

适配器模式的优点主要包括：

（1）提高类的透明性和复用性： 适配器模式可以让类在现有的基础上进行复用，而不需要做出任何改变，这有助于避免大规模改写现有代码。
（2）解耦目标类和适配器类： 通过使用适配器模式，目标类和适配器类可以实现解耦，从而提高程序的扩展性。这符合开闭原则，即对扩展开放，对修改关闭。
（3）更好的扩展性： 在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。
（4）灵活性好： 适配器并没有影响原有功能，如果不想使用，可以直接删除。

然而，适配器模式也存在一些缺点：

（1）增加系统复杂性： 适配器编写过程需要全面考虑，可能会增加系统的复杂性。
（2）降低代码可读性： 过多地使用适配器可能会使系统代码变得凌乱，增加代码阅读难度，降低代码可读性。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，如果系统中有太多这种情况，可能会使系统难以理解和维护。

因此，在使用适配器模式时，需要权衡其优缺点，根据具体场景和需求进行决策。如果不是很有必要，可以考虑不使用适配器，而是直接对系统进行重构。