【代码分析】初学解惑C++：函数适配器

前置知识 运算符的重载“（）”

---

一、函数适配器是什么？

(1). 简单来说函数适配器就是基于原有函数功能的基础上，再增加一些功能。跟pointer like class有些相似，都是想在原有的功能上，做更多的事情。
(2). 适配器的意思就是将某些已经存在的东西进行限制或者组合变成一个新的东西，这个新的东西体现一些新的特性，但底层都是由一些已经存在的东西实现的。

由遇到的问题引出适配器模式

适配器模式解决的问题在生活中经常会遇到：比如我们有一个 Team 为外界提供 S 类服务，但是我们 Team 里面没有能够完成此项人物的 member，然后我们得知有 A 可以完成这项服务（他把这项人物重新取了个名字叫 S’，并且他不对外公布他的具体实现）。为了保证我们对外的服务类别的一致性（提供 S 服务），我们有以下两种方式解决这个问题：

1）. 把 B 君直接招安到我们 Team 为我们工作，提供 S 服务的时候让 B 君去办就是了；

2）. B 君可能在别的地方有工作，并且不准备接受我们的招安，于是我们 Team 可以想这样一种方式解决问题： 我们安排 C
君去完成这项任务，并做好工作（Money）让 A 君工作的时候可以向 B 君请教，因此 C 君就是一个复合体（提供 S 服务，但是是 B 君的继承弟子）。

实际上在软件系统设计和开发中，这种问题也会经常遇到：我们为了完成某项工作购买了一个第三方的库来加快开发。这就带来了一个问题：我们在应用程序中已经设计好了接口，与这个第三方提供的接口不一致，为了使得这些接口不兼容的类（不能在一起工作）可以在一起工作了，适配器模式提供了将一个类（第三方库）的接口转化为客户（购买使用者）希望的接口。

在上面生活中问题的解决方式也就正好对应了适配器模式的两种类别：类模式和对象模式。

类模式

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

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

// 目标接口
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
35

对象模式

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

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

// 目标接口
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
42

例1

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

假设你正在开发一个文件读取器，但你决定使用第三方库来处理文件读取操作。第三方库提供了一个名为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
31

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

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

例2

// 目标接口
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接口进行操作。通过适配器模式，实现了不同接口之间的适配，使得它们能够在相同的上下文中工作。

例3

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

假设我们有两个不同的图形库，一个是"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
52

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

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

例4

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

假设你正在开发一个音频播放器应用程序，你使用了一个名为"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的一种实现。这样，我们就可以在不改变现有代码的情况下，通过适配器将两个不同的接口进行适配，使它们能够一起工作。加粗样式

二、实现函数适配器

注意：Adaptor和Adaptee都重载了“（）”，因此在调用参数时候可以一个套一个使用

1.定义函数

我们定义了一个仿函数类，该类很简单，就是把传入的flag，直接返回。

class RealTrue
{
	bool operator()(bool flag)
	{
		return flag;
	}
}
1
2
3
4
5
6
7

2.定义函数适配器

该适配器的功能是在原有功能的基础上，取反。

class RealTrueAdaptorNot
{
	protected:
		RealTrue opt;
		
	public:
		RealTrueAdaptorNot(RealTrue x) : opt(x){}
	 //重载了括号，所以RealTrueAdaptorNot（arg），arg的值给了opt(x)的x，又传给了flag
		bool operator()(bool flag)
		{
			return !opt(flag);
		}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.使用函数适配器

输出结果为false。

#include 
using namespace std;
int main()
{
	RealTrue rt;
	RealTrueAdaptorNot  not_rt(rt); //重载了括号，所以not_rt(rt)，rt == true 的值给了opt(x)的x，又传给了flag

	cout << not_rt(true) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10

三、带模板的函数适配器

所有符合以下条件的类，都可以用AdaptorNot类修饰。
	1.实现了operator()的重载。
	2.operator()的重载函数是如下的声明格式：bool operator()(bool 形参名字)
1
2
3

template <typename T>
class AdaptorNot
{
	protected:
		T opt;
	public:
		AdaptorNot(T x) : opt(x){}
		//重载了括号
		bool operator()(bool flag)
		{
			return !opt(flag);
		}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

有人又要说，我的形参不是bool类型的，AdaptorNot就无法修改了吧。
这确实是个问题，不过STL给出了一种解决方案。 提供了unary_function类。

1、自定义unary_function

只要类继承了my_unary_function类，就可以被下面的AdaptorNot适配。

template <typename arg,typename res>
struct my_unary_function
{
	typedef arg argument_type;
	typedef res result_type;
}
1
2
3
4
5
6

2、改写带模板的函数适配器

template <typename T>
class AdaptorNot
{
	protected:
		T opt;
	
	public:
		AdaptorNot(T x) : opt(x){}
		//重载了括号
		bool operator()(typename T::argument_type flag)
		{
			return !opt(flag);
		}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3、 自由参数类型调用函数适配器

只要类继承了my_unary_function类，就可以被AdaptorNot适配。
C++ STL中的函数适配器就是这个原理，只不过它用模板函数又包了一层，用起来更方便了。

class my_less_five : public my_unary_function<int,bool>
{
public:
 //重载了括号
	bool operator()(int x)
	{
		return x<5;
	}
}

int main()
{
	my_less_five less5; 
	AdaptorNot<my_less_five> not_less5;
	
	count << not_less5(3) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17