如何选择结构型模式？-优快云博客

接口不兼容 → 适配器
抽象与实现解耦 → 桥接
动态扩展功能 → 装饰器
处理树形结构 → 组合
简化复杂子系统 → 外观
优化资源占用 → 享元
控制对象访问 → 代理

适配器模式

适配器模式概述

适配器模式(Adapter Pattern)是一种结构型设计模式，它允许接口不兼容的类能够一起工作。适配器模式通过将一个类的接口转换成客户希望的另外一个接口，解决了由于接口不兼容而不能一起工作的类的问题。

核心角色

目标接口(Target): 客户端期望的接口
被适配者(Adaptee): 需要被适配的现有接口
适配器(Adapter): 将Adaptee接口转换为Target接口

两种实现方式

类适配器: 通过多重继承实现(Adapter继承Target和Adaptee)
对象适配器: 通过组合实现(Adapter持有Adaptee的引用)

使用场景

适配器模式在以下情况下特别有用：

系统需要使用现有的类，而这些类的接口不符合系统的需求
想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的类一起工作
需要统一多个不同接口的类
旧系统升级改造，需要保留旧系统的功能但又需要与新接口协同工作

C++代码实现示例

示例1：类适配器（通过多重继承）

#include <iostream>
#include <string>

// 目标接口（客户端期望的接口）
class Target {
public:
    virtual ~Target() = default;
    virtual std::string request() const {
        return "Target: 默认目标行为";
    }
};

// 被适配者（需要适配的类）
class Adaptee {
public:
    std::string specificRequest() const {
        return ".eetpadA eht fo roivaheb laicepS";
    }
};

// 适配器（通过多重继承适配）
class Adapter : public Target, private Adaptee {
public:
    Adapter() {}
    std::string request() const override {
        // 调用被适配者的方法并转换结果
        std::string to_reverse = this->specificRequest();
        std::reverse(to_reverse.begin(), to_reverse.end());
        return "Adapter: (翻译后) " + to_reverse;
    }
};

// 客户端代码
void clientCode(const Target *target) {
    std::cout << target->request();
}

int main() {
    std::cout << "客户端: 我能很好地与目标对象一起工作:\n";
    Target *target = new Target;
    clientCode(target);
    std::cout << "\n\n";
    
    Adaptee *adaptee = new Adaptee;
    std::cout << "客户端: Adaptee类有一个奇怪的接口。看不懂:\n";
    std::cout << "Adaptee: " << adaptee->specificRequest();
    std::cout << "\n\n";
    
    std::cout << "客户端: 但是通过适配器我能理解它:\n";
    Adapter *adapter = new Adapter;
    clientCode(adapter);
    std::cout << "\n";

    delete target;
    delete adaptee;
    delete adapter;

    return 0;
}

示例2：对象适配器（通过组合）

#include <iostream>
#include <string>
#include <algorithm>

// 目标接口
class MediaPlayer {
public:
    virtual ~MediaPlayer() = default;
    virtual void play(const std::string& audioType, const std::string& fileName) = 0;
};

// 高级媒体播放器接口
class AdvancedMediaPlayer {
public:
    virtual ~AdvancedMediaPlayer() = default;
    virtual void playVlc(const std::string& fileName) = 0;
    virtual void playMp4(const std::string& fileName) = 0;
};

// 具体高级播放器实现
class VlcPlayer : public AdvancedMediaPlayer {
public:
    void playVlc(const std::string& fileName) override {
        std::cout << "播放VLC文件: " << fileName << std::endl;
    }
    
    void playMp4(const std::string& /*fileName*/) override {}
};

class Mp4Player : public AdvancedMediaPlayer {
public:
    void playVlc(const std::string& /*fileName*/) override {}
    
    void playMp4(const std::string& fileName) override {
        std::cout << "播放MP4文件: " << fileName << std::endl;
    }
};

// 媒体适配器
class MediaAdapter : public MediaPlayer {
private:
    AdvancedMediaPlayer* advancedMusicPlayer;
    
public:
    MediaAdapter(const std::string& audioType) {
        if (audioType == "vlc") {
            advancedMusicPlayer = new VlcPlayer();
        } else if (audioType == "mp4") {
            advancedMusicPlayer = new Mp4Player();
        } else {
            advancedMusicPlayer = nullptr;
        }
    }
    
    ~MediaAdapter() {
        delete advancedMusicPlayer;
    }
    
    void play(const std::string& audioType, const std::string& fileName) override {
        if (audioType == "vlc") {
            advancedMusicPlayer->playVlc(fileName);
        } else if (audioType == "mp4") {
            advancedMusicPlayer->playMp4(fileName);
        }
    }
};

// 音频播放器
class AudioPlayer : public MediaPlayer {
private:
    MediaAdapter* mediaAdapter;
    
public:
    ~AudioPlayer() {
        delete mediaAdapter;
    }
    
    void play(const std::string& audioType, const std::string& fileName) override {
        // 内置支持MP3格式
        if (audioType == "mp3") {
            std::cout << "播放MP3文件: " << fileName << std::endl;
        } 
        // 适配器支持其他格式
        else if (audioType == "vlc" || audioType == "mp4") {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter->play(audioType, fileName);
        } 
        else {
            std::cout << "无效的媒体类型: " << audioType << std::endl;
        }
    }
};

// 客户端代码
int main() {
    AudioPlayer audioPlayer;
    
    audioPlayer.play("mp3", "song.mp3");
    audioPlayer.play("vlc", "movie.vlc");
    audioPlayer.play("mp4", "video.mp4");
    audioPlayer.play("avi", "movie.avi");
    
    return 0;
}

示例3：STL中的适配器

#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <deque>

// STL中的适配器示例
void stlAdapterExample() {
    // stack是适配器，默认使用deque作为底层容器
    std::stack<int> stackAdapter;
    
    // queue是适配器，默认使用deque作为底层容器
    std::queue<int> queueAdapter;
    
    // priority_queue是适配器，默认使用vector作为底层容器
    std::priority_queue<int> priorityQueueAdapter;
    
    // 可以使用不同的底层容器
    std::stack<int, std::vector<int>> vectorStack;
    std::queue<int, std::list<int>> listQueue;
}

int main() {
    stlAdapterExample();
    return 0;
}