設計模式 | 適配器模式

適配器模式（Adapter Pattern）?是結構型設計模式中的連接器大師，它允許不兼容接口的類能夠協同工作。本文將深入探索適配器模式的核心思想、實現技巧以及在C++中的高效實踐，解決現實開發中的接口兼容性問題。

為什么需要適配器模式

在軟件開發中，我們經常遇到接口不兼容的情況：

遺留系統與現代框架的集成
第三方庫與自有系統的對接
不同子系統之間的數據交換
API升級導致的接口變更

直接修改已有代碼通常不可行：

第三方庫無法修改
舊系統代碼難以重構
新老系統需要并行運行
修改可能引入新錯誤

適配器模式通過創建中間轉換層解決了這些問題，成為系統集成的關鍵橋梁。

適配器模式的核心概念

模式結構解析

[客戶端] --> [目標接口]↑[適配器] ---> [被適配者]

關鍵角色定義

目標接口（Target）
- 客戶端期望的接口
被適配者（Adaptee）
- 需要適配的現有組件
適配器（Adapter）
- 轉換接口的中間件
- 實現目標接口
- 包裝被適配者

C++實現：電源適配器系統

讓我們通過電源適配器系統展示適配器模式的實際應用：

#include <iostream>
#include <memory>
#include <cmath>
#include <iomanip>// ================ 目標接口：現代電源標準 ================
class ModernPowerOutlet {
public:virtual ~ModernPowerOutlet() = default;// 輸出標準USB-C電源virtual void supplyPower() const = 0;// 獲取電源規格virtual void getSpecs() const {std::cout << "標準: USB-C PD 3.1\n";std::cout << "電壓: 5V-48V\n";std::cout << "功率: 最高240W\n";}
};// ================ 被適配者：舊式電源接口 ================
class LegacyPowerOutlet {
public:// 舊式交流電源輸出void outputACPower(int voltage, int current) const {std::cout << "輸出交流電: " << voltage << "V, " << current << "A\n";}// 獲取舊式電源規格void showLegacySpecs() const {std::cout << "=== 舊式電源規格 ===\n";std::cout << "類型: 交流電\n";std::cout << "電壓: 110V/220V\n";std::cout << "頻率: 50/60Hz\n";}
};// ================ 類適配器（多重繼承） ================
class PowerClassAdapter : public ModernPowerOutlet, private LegacyPowerOutlet {
public:void supplyPower() const override {std::cout << "轉換交流到直流...\n";// 調用被適配者的方法outputACPower(220, 5); std::cout << "輸出: USB-C 20V/5A (100W)\n";}void getSpecs() const override {ModernPowerOutlet::getSpecs();std::cout << "適配器類型: 類適配器\n";showLegacySpecs();}
};// ================ 對象適配器（組合方式） ================
class PowerObjectAdapter : public ModernPowerOutlet {
public:// 通過構造函數注入被適配對象explicit PowerObjectAdapter(LegacyPowerOutlet* outlet) : legacyOutlet_(outlet) {}void supplyPower() const override {std::cout << "轉換交流到直流...\n";// 調用被適配者的方法legacyOutlet_->outputACPower(220, 5);std::cout << "輸出: USB-C 20V/5A (100W)\n";}void getSpecs() const override {ModernPowerOutlet::getSpecs();std::cout << "適配器類型: 對象適配器\n";legacyOutlet_->showLegacySpecs();}private:LegacyPowerOutlet* legacyOutlet_;
};// ================ 客戶端代碼 ================
void chargeDevice(ModernPowerOutlet* outlet) {std::cout << "\n=== 開始充電 ===\n";outlet->getSpecs();outlet->supplyPower();std::cout << "設備充電中...\n";std::cout << "=== 充電完成 ===\n";
}int main() {// 創建被適配對象LegacyPowerOutlet legacyOutlet;// 使用類適配器std::cout << "===== 使用類適配器 =====\n";PowerClassAdapter classAdapter;chargeDevice(&classAdapter);// 使用對象適配器std::cout << "\n\n===== 使用對象適配器 =====\n";PowerObjectAdapter objectAdapter(&legacyOutlet);chargeDevice(&objectAdapter);return 0;
}

適配器模式的兩種實現方式

1. 類適配器（繼承方式）

class ClassAdapter : public Target, private Adaptee {
public:void request() override {// 轉換并調用被適配者的方法specificRequest();}
};

特點：

使用多重繼承
適配器繼承目標接口和被適配者
靜態綁定，編譯時確定
可能違反單一職責原則

2. 對象適配器（組合方式）

class ObjectAdapter : public Target {
public:ObjectAdapter(Adaptee* adaptee) : adaptee_(adaptee) {}void request() override {// 轉換并調用被適配者的方法adaptee_->specificRequest();}private:Adaptee* adaptee_;
};

特點：

使用對象組合
更靈活，支持運行時適配
符合合成復用原則
可以適配多個對象
現代C++更推薦的方式

適配器模式的高級應用

1. 雙向適配器

class BiDirectionalAdapter : public NewInterface, public OldInterface {
public:BiDirectionalAdapter(OldSystem* old, NewSystem* newSys) : oldSystem_(old), newSystem_(newSys) {}// 實現新接口void newMethod() override {oldSystem_->legacyMethod();}// 實現舊接口void legacyMethod() override {newSystem_->newMethod();}private:OldSystem* oldSystem_;NewSystem* newSystem_;
};

2. 參數適配器

class FunctionAdapter {
public:using NewSignature = void(int, double);explicit FunctionAdapter(std::function<void(std::string, float)> oldFunc): oldFunc_(oldFunc) {}void operator()(int a, double b) {// 轉換參數并調用舊函數oldFunc_(std::to_string(a), static_cast<float>(b));}private:std::function<void(std::string, float)> oldFunc_;
};// 使用
void legacyPrint(std::string s, float f) {std::cout << s << " : " << f << "\n";
}int main() {FunctionAdapter adapter(legacyPrint);adapter(42, 3.14); // 自動轉換參數類型
}

3. STL中的適配器

#include <vector>
#include <stack>
#include <queue>
#include <functional>// 容器適配器示例
std::stack<int> s;              // deque適配為棧
std::queue<double> q;           // deque適配為隊列
std::priority_queue<int> pq;    // vector適配為優先隊列// 函數對象適配器
auto negate = std::negate<int>();
auto plus10 = std::bind(std::plus<int>(), std::placeholders::_1, 10);
auto isEven = [](int x) { return x % 2 == 0; };
auto isOdd = std::not1(std::function<bool(int)>(isEven));

適配器模式的現實應用場景

1. 圖形渲染接口適配

// OpenGL接口
class OpenGLRenderer {
public:void glClearColor(float r, float g, float b, float a) {std::cout << "OpenGL: 設置清除顏色 (" << r << ", " << g << ", " << b << ", " << a << ")\n";}// 其他OpenGL方法...
};// Vulkan接口適配器
class VulkanToOpenGLAdapter : public OpenGLRenderer {
public:void vkCmdClearColor(float r, float g, float b, float a) {// 將Vulkan命令轉換為OpenGL調用glClearColor(r, g, b, a);}// 其他適配方法...
};

2. 支付系統集成

// 統一支付接口
class PaymentProcessor {
public:virtual void processPayment(double amount, const std::string& currency) = 0;
};// PayPal適配器
class PayPalAdapter : public PaymentProcessor {
public:PayPalAdapter(PayPalService* paypal) : paypal_(paypal) {}void processPayment(double amount, const std::string& currency) override {// 轉換到PayPal要求的格式paypal_->sendPayment(amount * 100, currency + "_MICRO");}private:PayPalService* paypal_;
};// Stripe適配器
class StripeAdapter : public PaymentProcessor {
public:void processPayment(double amount, const std::string& currency) override {stripe::Charge::create({{"amount", static_cast<int>(amount * 100)},{"currency", currency}});}
};

3. 傳感器數據標準化

// 統一傳感器接口
class Sensor {
public:virtual double read() const = 0;virtual std::string getUnit() const = 0;
};// 溫度傳感器適配器
class TemperatureAdapter : public Sensor {
public:TemperatureAdapter(LegacyThermometer* thermo) : thermo_(thermo) {}double read() const override {// 華氏度轉攝氏度return (thermo_->getFahrenheit() - 32) * 5/9;}std::string getUnit() const override {return "°C";}private:LegacyThermometer* thermo_;
};// 壓力傳感器適配器
class PressureAdapter : public Sensor {
public:PressureAdapter(BarometricSensor* sensor) : sensor_(sensor) {}double read() const override {// mmHg轉hPareturn sensor_->getmmHg() * 1.33322;}std::string getUnit() const override {return "hPa";}private:BarometricSensor* sensor_;
};

適配器模式的五大優勢

接口兼容性

// 舊接口
void legacyPrint(int x, float y);// 新接口適配器
class PrinterAdapter {
public:void print(double a, double b) {legacyPrint(static_cast<int>(a), static_cast<float>(b));}
};

代碼復用

// 復用現有實現
class NewServiceAdapter : public NewServiceInterface {
public:NewServiceAdapter(OldService* service) : service_(service) {}void newMethod() override {service_->oldMethod(); // 復用舊實現}
};

解耦系統

// 客戶端只依賴抽象接口
void clientCode(DataProcessor* processor) {processor->process(data);
}// 適配不同實現
clientCode(new XMLProcessorAdapter(xmlParser));
clientCode(new JSONProcessorAdapter(jsonParser));

增量遷移

// 逐步替換舊系統
class HybridSystem : public NewSystem {
public:HybridSystem(OldSystem* old) : oldAdapter_(old) {}void newOperation() override {if (useOldSystem) {oldAdapter_.legacyOperation();} else {NewSystem::newOperation();}}
};

多平臺支持

// 跨平臺文件系統適配
class FileSystemAdapter {
public:#ifdef _WIN32WindowsFileSys winFS;#elif __APPLE__MacFileSys macFS;#elif __linux__LinuxFileSys linuxFS;#endifstd::string readFile(const std::string& path) {#ifdef _WIN32return winFS.readWinFile(path);#elif __APPLE__return macFS.readMacFile(path);// ...#endif}
};

適配器模式的最佳實踐

1. 優先使用對象適配器

// 更靈活，支持運行時配置
class FlexibleAdapter : public Target {
public:FlexibleAdapter(Adaptee* adaptee) : adaptee_(adaptee) {}// 實現目標接口...private:Adaptee* adaptee_; // 組合優于繼承
};

2. 使用智能指針管理資源

class SafeAdapter : public Target {
public:SafeAdapter(std::shared_ptr<Adaptee> adaptee) : adaptee_(std::move(adaptee)) {}// 實現目標接口...private:std::shared_ptr<Adaptee> adaptee_;
};// 使用
auto adaptee = std::make_shared<LegacyComponent>();
SafeAdapter adapter(adaptee);

3. 保持適配器輕量級

// 只包含必要的轉換邏輯
class MinimalAdapter : public NewInterface {
public:MinimalAdapter(OldComponent* comp) : comp_(comp) {}void newMethod() override {// 只做必要轉換comp_->oldMethod();}// 不實現不需要的方法
};

4. 適配器命名規范

// 清晰表達適配關系
class LegacyToModernAdapter   // 舊系統到新系統
class XMLToJSONAdapter       // XML到JSON轉換
class FahrenheitToCelsiusAdapter // 溫度單位轉換
class PayPalPaymentAdapter   // PayPal支付適配

適配器模式與其他模式的關系

模式	關系	區別
裝飾器模式	都使用包裝	裝飾器添加功能，適配器轉換接口
外觀模式	都簡化接口	外觀定義新接口，適配器復用現有接口
橋接模式	都解耦抽象與實現	橋接預先設計，適配器事后補救
代理模式	都使用間接訪問	代理控制訪問，適配器轉換接口

組合使用示例：

// 適配器 + 工廠模式
class PaymentAdapterFactory {
public:static PaymentProcessor* createAdapter(PaymentType type) {switch (type) {case PAYPAL: return new PayPalAdapter(new PayPalService);case STRIPE: return new StripeAdapter;case CRYPTO: return new CryptoPaymentAdapter;default: throw std::invalid_argument("不支持的支付類型");}}
};// 客戶端代碼
auto processor = PaymentAdapterFactory::createAdapter(PAYPAL);
processor->processPayment(99.99, "USD");

應用案例

1. 數據庫訪問層適配

// 統一數據庫接口
class Database {
public:virtual void execute(const std::string& query) = 0;
};// MySQL適配器
class MySQLAdapter : public Database {
public:MySQLAdapter(MySQLConn* conn) : conn_(conn) {}void execute(const std::string& query) override {conn_->mysql_exec(query.c_str());}
};// PostgreSQL適配器
class PostgresAdapter : public Database {
public:void execute(const std::string& query) override {PGresult* res = PQexec(conn_, query.c_str());// 處理結果...}
};// SQLite適配器
class SQLiteAdapter : public Database {
public:void execute(const std::string& query) override {sqlite3_exec(db_, query.c_str(), nullptr, nullptr, nullptr);}
};

2. 日志系統集成

// 統一日志接口
class Logger {
public:virtual void log(LogLevel level, const std::string& message) = 0;
};// Log4cpp適配器
class Log4cppAdapter : public Logger {
public:Log4cppAdapter(log4cpp::Category* cat) : category_(cat) {}void log(LogLevel level, const std::string& msg) override {switch (level) {case DEBUG: category_->debug(msg); break;case INFO: category_->info(msg); break;case WARN: category_->warn(msg); break;case ERROR: category_->error(msg); break;}}
};// Boost.Log適配器
class BoostLogAdapter : public Logger {
public:void log(LogLevel level, const std::string& msg) override {switch (level) {case DEBUG: BOOST_LOG_TRIVIAL(debug) << msg; break;case INFO: BOOST_LOG_TRIVIAL(info) << msg; break;case WARN: BOOST_LOG_TRIVIAL(warning) << msg; break;case ERROR: BOOST_LOG_TRIVIAL(error) << msg; break;}}
};

3. 跨平臺UI框架

// 統一UI組件接口
class UIButton {
public:virtual void render(int x, int y, int width, int height) = 0;
};// Windows按鈕適配器
class WinButtonAdapter : public UIButton {
public:void render(int x, int y, int w, int h) override {HWND button = CreateWindow("BUTTON", "Click", WS_VISIBLE | WS_CHILD,x, y, w, h, parent, NULL, NULL, NULL);}
};// macOS按鈕適配器
class MacButtonAdapter : public UIButton {
public:void render(int x, int y, int w, int h) override {NSButton* button = [[NSButton alloc] initWithFrame:NSMakeRect(x, y, w, h)];[button setTitle:@"Click"];[parent addSubview:button];}
};// Linux按鈕適配器
class LinuxButtonAdapter : public UIButton {
public:void render(int x, int y, int w, int h) override {GtkWidget* button = gtk_button_new_with_label("Click");gtk_fixed_put(GTK_FIXED(container), button, x, y);gtk_widget_set_size_request(button, w, h);}
};

適配器模式的挑戰與解決方案

挑戰	解決方案
接口差異過大	使用雙向適配器或中間抽象層
適配器過多導致混亂	使用工廠模式管理適配器創建
性能開銷	優化轉換邏輯，緩存常用結果
鏈式適配問題	避免多層嵌套，使用組合適配器

性能優化示例：

class CachingAdapter : public Target {
public:void request() override {if (!cached) {result = adaptee_->computeExpensiveOperation();cached = true;}// 使用緩存結果processResult(result);}
};