C++适配器模式

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许将一个类的接口转换成客户端所期望的另一个接口。适配器模式通常用于解决两个已有接口之间不兼容的问题。

在C++中，适配器模式可以通过类适配器和对象适配器两种方式实现。

1. 类适配器模式：
   类适配器模式使用继承来实现适配器。适配器类继承自目标接口（通常是一个抽象类），并且同时继承自被适配的类（也可以是一个类或者接口）。适配器类通过调用被适配类的方法来实现目标接口的方法。

   以下是一个使用类适配器模式的简单示例：

// 目标接口
class Target {
public:
    virtual void request() = 0;
};

// 被适配类
class Adaptee {
public:
    void specificRequest() {
        // 执行特定的操作
    }
};

// 适配器类
class Adapter : public Target, private Adaptee {
public:
    void request() override {
        specificRequest();  // 调用被适配类的方法
    }
};

// 客户端代码
void clientCode(Target* target) {
    target->request();
}

int main() {
    Target* target = new Adapter();
    clientCode(target);
    delete target;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2. 对象适配器模式：
   对象适配器模式使用对象组合来实现适配器。适配器类包含一个被适配的对象作为成员，并实现目标接口的方法，通过调用被适配对象的方法来实现目标接口的方法。

   以下是一个使用对象适配器模式的简单示例：

// 目标接口
class Target {
public:
    virtual void request() = 0;
};

// 被适配类
class Adaptee {
public:
    void specificRequest() {
        // 执行特定的操作
    }
};

// 适配器类
class Adapter : public Target {
private:
    Adaptee* adaptee;  // 被适配对象

public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}

    void request() override {
        adaptee->specificRequest();  // 调用被适配对象的方法
    }
};

// 客户端代码
void clientCode(Target* target) {
    target->request();
}

int main() {
    Adaptee* adaptee = new Adaptee();
    Target* target = new Adapter(adaptee);
    clientCode(target);
    delete target;
    delete adaptee;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

适配器模式可以帮助在不改变现有代码的情况下，将不兼容的接口进行适配，使得它们能够一起工作。通过使用适配器模式，

可以提高代码的可重用性和灵活性。

例子

当使用第三方库或旧版本库时，你可能需要使用适配器模式来适应现有的接口。以下是一个例子：

假设你正在开发一个文件读取器，但你决定使用第三方库来处理文件读取操作。第三方库提供了一个名为ThirdPartyFileReader的类，它具有不同于你期望的接口。你希望在你的代码中使用统一的接口FileReader来读取文件。

使用类适配器模式的示例代码如下：

// 目标接口
class FileReader {
public:
    virtual void readFile() = 0;
};

// 第三方库的文件读取类
class ThirdPartyFileReader {
public:
    void read() {
        // 使用第三方库的方式读取文件
    }
};

// 适配器类（类适配器模式）
class Adapter : public FileReader, private ThirdPartyFileReader {
public:
    void readFile() override {
        read();  // 调用第三方库的方法
    }
};

// 客户端代码
int main() {
    FileReader* reader = new Adapter();
    reader->readFile();
    delete reader;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在这个例子中，ThirdPartyFileReader是被适配的类，它具有不兼容的接口。Adapter是适配器类，它继承了ThirdPartyFileReader，同时实现了FileReader的接口。适配器类中的readFile方法通过调用被适配类的read方法来实现文件读取操作。

通过使用适配器模式，你可以将第三方库的文件读取操作适配为符合你的代码设计的接口，使得你的代码可以统一使用FileReader来进行文件读取，而无需直接与第三方库的接口交互。

当使用适配器模式时，常见的一个例子是将不同的日期类进行适配，以实现对外提供统一的日期操作接口。

假设有两个已有的日期类：DateA和DateB，它们具有不同的接口和实现。现在需要对外提供一个统一的日期操作接口Date，可以使用适配器模式进行适配。

以下是一个简化的示例代码：

// 目标接口
class Date {
public:
    virtual void printDate() = 0;
};

// 被适配类 - DateA
class DateA {
public:
    void display() {
        // DateA的特定实现
        cout << "DateA: 2023-06-05" << endl;
    }
};

// 被适配类 - DateB
class DateB {
public:
    void show() {
        // DateB的特定实现
        cout << "DateB: 06/05/2023" << endl;
    }
};

// 适配器类
class DateAdapter : public Date {
private:
    DateA dateA;  // 被适配对象 - DateA

public:
    void printDate() override {
        dateA.display();  // 调用DateA的方法
    }
};

// 客户端代码
void clientCode(Date* date) {
    date->printDate();
}

int main() {
    DateAdapter adapter;  // 使用适配器将DateA适配为Date接口
    clientCode(&adapter);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

在上述示例中，通过适配器类DateAdapter将DateA适配为Date接口。适配器类中使用了DateA作为成员对象，并实现了Date接口的方法，内部调用了DateA的方法。

这样，无论是使用DateA还是DateB，都可以通过适配器模式提供的统一的Date接口进行操作。通过适配器模式，实现了不同接口之间的适配，使得它们能够在相同的上下文中工作。

当涉及到适配器模式时，一个常见的例子是将不同的图形库适配到统一的图形接口上。

假设我们有两个不同的图形库，一个是"LegacyGraphics"（遗留图形库），另一个是"ModernGraphics"（现代图形库）。这两个图形库具有不同的接口和实现方式。

现在我们想要使用一个统一的图形接口"Graphics"来绘制图形，但是"LegacyGraphics"和"ModernGraphics"的接口与"Graphics"的接口不兼容。

这时候可以使用适配器模式来解决这个问题。下面是一个使用对象适配器模式的示例：

// 目标接口
class Graphics {
public:
    virtual void drawLine(int x1, int y1, int x2, int y2) = 0;
    virtual void drawRectangle(int x, int y, int width, int height) = 0;
};

// 被适配的"LegacyGraphics"类
class LegacyGraphics {
public:
    void draw(int x1, int y1, int x2, int y2) {
        // 使用(x1, y1)和(x2, y2)绘制线条的逻辑
    }

    void draw(int x, int y, int width, int height) {
        // 使用(x, y)、width和height绘制矩形的逻辑
    }
};

// 适配器类
class LegacyGraphicsAdapter : public Graphics {
private:
    LegacyGraphics* legacyGraphics;

public:
    LegacyGraphicsAdapter(LegacyGraphics* legacyGraphics) : legacyGraphics(legacyGraphics) {}

    void drawLine(int x1, int y1, int x2, int y2) override {
        legacyGraphics->draw(x1, y1, x2, y2);
    }

    void drawRectangle(int x, int y, int width, int height) override {
        legacyGraphics->draw(x, y, width, height);
    }
};

// 客户端代码
void clientCode(Graphics* graphics) {
    graphics->drawLine(0, 0, 100, 100);
    graphics->drawRectangle(50, 50, 200, 100);
}

int main() {
    LegacyGraphics* legacyGraphics = new LegacyGraphics();
    Graphics* adapter = new LegacyGraphicsAdapter(legacyGraphics);
    clientCode(adapter);
    delete adapter;
    delete legacyGraphics;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

在上述示例中，"Graphics"是目标接口，"LegacyGraphics"是被适配的类，"LegacyGraphicsAdapter"是适配器类。通过适配器类，我们可以使用统一的"Graphics"接口来调用"LegacyGraphics"的方法，从而实现了不同图形库的适配。

这个例子展示了如何使用适配器模式来解决不同接口之间的兼容性问题，并实现了统一的图形接口来绘制图形，而不需要改动现有的图形库代码。

当你使用第三方库或框架时，你可能会遇到需要适配其接口以与你的代码进行交互的情况。以下是一个示例：

假设你正在开发一个音频播放器应用程序，你使用了一个名为"AudioPlayer"的第三方音频播放库。该库提供了一个名为"playAudio"的方法来播放音频文件，但是你的应用程序中已经存在了一个名为"playMusic"的方法来播放音乐。为了让这两个方法兼容，你可以使用适配器模式。

// 目标接口
class MusicPlayer {
public:
    virtual void playMusic() = 0;
};

// 被适配类
class AudioPlayer {
public:
    void playAudio() {
        // 播放音频文件
    }
};

// 适配器类
class AudioPlayerAdapter : public MusicPlayer {
private:
    AudioPlayer* audioPlayer;

public:
    AudioPlayerAdapter(AudioPlayer* player) : audioPlayer(player) {}

    void playMusic() override {
        audioPlayer->playAudio();  // 调用被适配类的方法
    }
};

// 客户端代码
int main() {
    AudioPlayer* audioPlayer = new AudioPlayer();
    MusicPlayer* musicPlayer = new AudioPlayerAdapter(audioPlayer);
    musicPlayer->playMusic();

    delete musicPlayer;
    delete audioPlayer;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

在上述示例中，通过适配器类AudioPlayerAdapter，我们将AudioPlayer类的playAudio方法适配到了MusicPlayer接口的playMusic方法上，从而使得原本不兼容的接口能够一起工作。

通过适配器模式，你可以使用第三方库的功能，同时保持你的代码结构不变，并且可以更灵活地在你的应用程序中使用这些功能。

在这个示例中，首先创建了一个AudioPlayer对象audioPlayer，它是第三方音频播放库提供的类。然后，通过创建一个AudioPlayerAdapter对象audioPlayerAdapter，将audioPlayer对象适配到了MusicPlayer接口上。

通过以下代码创建适配器对象：

AudioPlayer* audioPlayer = new AudioPlayer();
MusicPlayer* musicPlayer = new AudioPlayerAdapter(audioPlayer);
1
2

这里的AudioPlayerAdapter类的构造函数接受一个AudioPlayer对象作为参数，将其保存为适配器的成员变量。

最后，通过调用musicPlayer对象的playMusic方法来播放音乐：

musicPlayer->playMusic();
1

这个调用实际上会触发AudioPlayerAdapter类中的playMusic方法，在该方法内部会调用被适配类AudioPlayer的playAudio方法。

通过适配器模式，我们可以使用AudioPlayer对象来实现MusicPlayer接口中的playMusic方法，使得原本不兼容的AudioPlayer类可以被视为MusicPlayer的一种实现。这样，我们就可以在不改变现有代码的情况下，通过适配器将两个不同的接口进行适配，使它们能够一起工作。