突破编程_C++_设计模式（桥接模式）_c++ 桥接模式

1 桥接模式的基本概念

桥接模式（Bridge Pattern）是一种结构型设计模式，它的基本概念是将抽象部分与它的实现部分分离，使它们都可以独立地变化。在桥接模式中，抽象部分和实现部分被放在两个不同的类层次中，这样它们就可以独立地进行改变，而不会影响到对方。

具体来说，桥接模式包含两个层次的类：抽象层次和实现层次。抽象层次定义了抽象接口，它包含了一些抽象方法，这些方法的具体实现在实现层次中实现。实现层次的类实现了抽象层次定义的接口，并提供了具体的方法实现。

2 桥接模式的实现步骤

在C++中实现桥接模式通常涉及以下步骤：

（1）定义抽象接口： 首先，需要定义一个抽象的接口，这个接口声明了将要由实现类提供的方法。这个接口通常是一个纯虚函数类。

（2）定义实现接口： 然后，需要定义一个或多个实现接口。这些接口定义了实现抽象接口所需的具体方法。

（3）实现类： 接着，创建实现了抽象接口和实现接口的类。这些类通常被称为实现类，因为它们提供了抽象接口的具体实现。

（4）引用类： 创建一个或多个引用类，这些类持有对实现类对象的引用。引用类将客户端代码与具体实现解耦，客户端代码只与抽象接口打交道。

（5）客户端代码： 最后，在客户端代码中，可以使用引用类的对象来调用抽象接口的方法。由于引用类持有实现类对象的引用，因此这些方法的具体实现由实现类提供。

下面是一个简单的桥接模式实现示例：

#include <iostream>  
#include <memory>  

// 抽象接口  
class Abstraction 
{
public:
	virtual void operation() = 0; // 纯虚函数  
	virtual ~Abstraction() = default; // 虚析构函数  
};

// 实现接口  
class Implementor 
{
public:
	virtual void implement() = 0; // 纯虚函数  
	virtual ~Implementor() = default; // 虚析构函数  
};

// 具体实现类  
class ConcreteImplementorA : public Implementor 
{
public:
	void implement() override {
		std::cout << "ConcreteImplementorA::implement()" << std::endl;
	}
};

class ConcreteImplementorB : public Implementor 
{
public:
	void implement() override {
		std::cout << "ConcreteImplementorB::implement()" << std::endl;
	}
};

// 引用类，持有实现类的智能指针  
class RefinedAbstraction : public Abstraction 
{
private:
	std::unique_ptr<Implementor> implementor;
public:
	RefinedAbstraction(std::unique_ptr<Implementor> impl) : implementor(std::move(impl)) {}

	void operation() override {
		implementor->implement();
		// 可能还有其他操作  
	}
};

// 客户端代码  
int main() 
{
	// 创建具体实现类的智能指针对象  
	auto implA = std::make_unique<ConcreteImplementorA>();
	auto implB = std::make_unique<ConcreteImplementorB>();

	// 创建引用类的对象，并将具体实现对象的智能指针传递给它  
	std::unique_ptr<Abstraction> abstractionA = std::make_unique<RefinedAbstraction>(std::move(implA));
	std::unique_ptr<Abstraction> abstractionB = std::make_unique<RefinedAbstraction>(std::move(implB));

	// 使用引用类的对象调用方法  
	abstractionA->operation();
	abstractionB->operation();

	// 智能指针会自动管理内存，无需手动清理  
	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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

上面代码的输出为：

ConcreteImplementorA::implement()
ConcreteImplementorB::implement()
1
2

在上面代码中，Abstraction 是抽象接口，Implementor 是实现接口，ConcreteImplementorA 和 ConcreteImplementorB 是具体实现类，RefinedAbstraction 是引用类。在客户端代码中，创建了具体实现类的实例，并将它们传递给引用类，然后通过引用类来调用实现的方法。这样，客户端代码就无需知道具体实现类的存在，实现了抽象与实现的解耦。

3 桥接模式的应用场景

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

（1）提高系统灵活性： 当系统需要在抽象化角色和具体化角色之间增加更多的灵活性，避免静态的继承联系时，可以使用桥接模式。例如，在图形处理系统中，图形可以按照形状和颜色进行分类。如果使用继承方式，每种形状和颜色的组合都需要创建一个新的类，导致类的数量剧增且不易管理。而桥接模式可以通过将形状和颜色分离为两个独立的接口，并通过组合的方式将它们组合在一起，从而提高系统的灵活性。

（2）降低类之间的耦合度： 当系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时，桥接模式是一个很好的选择。通过桥接模式，可以将抽象部分和实现部分分离，使它们可以独立地变化。这样，抽象类和具体实现类之间的耦合度就会降低，减少代码量，降低系统的管理和维护成本。

（3）处理多个独立变化维度： 当一个类存在两个或多个独立变化的维度，且这些维度都需要进行扩展时，桥接模式是一个理想的选择。例如，在消息管理系统中，消息可以按照类型和分类进行划分。每种类型和分类的组合都需要创建一个新的类，导致类的数量剧增。而桥接模式可以将类型和分类分别抽象为两个独立的接口，并通过组合的方式将它们组合在一起，从而实现灵活的扩展。

总体而言，桥接模式主要适用于需要提高系统灵活性、降低类之间耦合度、减少代码量以及处理多个独立变化维度的场景。通过将这些场景与桥接模式相结合，可以设计出更加灵活、可扩展和可维护的系统。

3.1 桥接模式在提高系统灵活性的典型应用

在 C++ 中，桥接模式可以显著提高系统的灵活性，特别是在处理具有多个独立变化维度的场景时。以图形处理系统为例，可以将图形划分为两个独立变化的维度：图形的形状（如圆形、矩形、三角形等）和图形的颜色（如红色、绿色、蓝色等）。使用桥接模式，可以轻松扩展这两个维度，而不需要为每个组合创建新的类。

以下是一个桥接模式在图形处理系统中提高灵活性的典型应用示例：

首先，定义两个抽象接口：Shape（形状）和Color（颜色）：

#include <iostream>  
#include <memory> 

// 形状接口  
class Shape {
public:
	virtual void draw() = 0;
	virtual ~Shape() = default;
};

// 颜色接口  
class Color {
public:
	virtual void fill() = 0;
	virtual ~Color() = default;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

然后，创建实现了这些接口的具体类：

// 具体形状类：圆形  
class Circle : public Shape {
public:
	void draw() override {
		std::cout << "Circle::draw" << std::endl;
	}
};

// 具体形状类：矩形  
class Rectangle : public Shape {
public:
	void draw() override {
		std::cout << "Rectangle::draw" << std::endl;
	}
};

// 具体颜色类：红色  
class Red : public Color {
public:
	void fill() override {
		std::cout << "Red::fill" << std::endl;
	}
};

// 具体颜色类：绿色  
class Green : public Color {
public:
	void fill() override {
		std::cout << "Green::fill" << std::endl;
	}
};
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

接下来，创建一个桥接类 Graphic，它包含对 Shape 和 Color 的引用：

// 桥接类：图形  
class Graphic {
public:
	Graphic(std::shared_ptr<Shape> shape, std::shared_ptr<Color> color) : shape(shape), color(color) {}

	void render() {
		shape->draw();
		color->fill();
	}

	void setShape(std::shared_ptr<Shape> shape) { this->shape = shape; }
	void setColor(std::shared_ptr<Color> color) { this->color = color; }

protected:
	std::shared_ptr<Shape> shape;
	std::shared_ptr<Color> color;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

最后，在客户端代码中，可以动态地组合不同的形状和颜色，而不需要创建大量的具体图形类：

// 客户端代码  
int main() 
{
	// 创建具体的形状和颜色对象  
	std::shared_ptr<Shape> circle = std::make_shared<Circle>();
	std::shared_ptr<Shape> rectangle = std::make_shared<Rectangle>();
	std::shared_ptr<Color> red = std::make_shared<Red>();
	std::shared_ptr<Color> green = std::make_shared<Green>();

	// 创建桥接对象并组合形状和颜色  
	std::shared_ptr<Graphic> redCircle = std::make_shared<Graphic>(circle, red);
	std::shared_ptr<Graphic> greenRectangle = std::make_shared<Graphic>(rectangle, green);

	// 渲染图形  
	redCircle->render(); // 绘制红色圆形  
	greenRectangle->render(); // 绘制绿色矩形  

	// 动态更改图形的颜色或形状  
	redCircle->setColor(green); // 现在红色圆形变成了绿色圆形  
	greenRectangle->setShape(circle); // 现在绿色矩形变成了绿色圆形

	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

在这个例子中，桥接模式允许独立地扩展形状和颜色的类，而不需要为每一种形状和颜色的组合创建新的类。通过动态组合不同的形状和颜色对象，我们可以灵活地创建和修改图形，从而提高了系统的灵活性。此外，由于桥接模式将抽象与实现解耦，它也使得系统更易于维护和扩展。

3.2 桥接模式在降低类之间耦合度的典型应用

在 C++ 中，桥接模式通过将一个抽象部分与它的实现部分分离，使得它们可以独立地变化，从而降低了类之间的耦合度。这种分离有助于减少代码之间的依赖关系，使得系统更加灵活和可维护。下面是一个 C++ 中使用桥接模式降低类之间耦合度的典型应用示例：

假设有一个多媒体播放系统，其中包含了不同类型的媒体播放器（如音频播放器、视频播放器）和不同类型的媒体文件（如MP3、MP4）。此时希望设计一个系统，使得添加新的媒体播放器或媒体文件类型时，不需要修改现有的类。

首先，定义两个抽象接口：MediaPlayer（媒体播放器）和MediaFile（媒体文件）：

// 媒体文件接口  
class MediaFile {
public:
	virtual void open() = 0;
	virtual ~MediaFile() = default;
};

// 媒体播放器接口  
class MediaPlayer {
public:
	virtual void play(std::shared_ptr<MediaFile> file) = 0;
	virtual ~MediaPlayer() = default;
};
1
2
3
4
5
6
7
8
9
10
11
12
13

然后，创建具体的媒体播放器类和媒体文件类：

// MP3播放器类  
class MP3Player : public MediaPlayer {
public:
	void play(std::shared_ptr<MediaFile> file) override {
		file->open();
		std::cout << "Playing MP3 file" << std::endl;
	}
};

// MP4播放器类  
class MP4Player : public MediaPlayer {
public:
	void play(std::shared_ptr<MediaFile> file) override {
		file->open();
		std::cout << "Playing MP4 file" << std::endl;
	}
};

// MP3文件类  
class MP3File : public MediaFile {
public:
	void open() override {
		std::cout << "Opening MP3 file" << std::endl;
	}
};

// MP4文件类  
class MP4File : public MediaFile {
public:
	void open() override {
		std::cout << "Opening MP4 file" << std::endl;
	}
};
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

接下来，创建一个桥接类MediaBridge，它持有对MediaPlayer和MediaFile的引用，并实现了播放逻辑：

// 桥接类  
class MediaBridge {
protected:
	std::shared_ptr<MediaPlayer> player;
	std::shared_ptr<MediaFile> file;

public:
	MediaBridge(std::shared_ptr<MediaPlayer> player, std::shared_ptr<MediaFile> file)
		: player(player), file(file) {}

	void play() {
		player->play(file);
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

最后，在客户端代码中，我们可以使用桥接类来组合不同的媒体播放器和媒体文件，而不需要修改现有的类：

int main() 
{
	// 创建具体的媒体播放器和媒体文件对象的shared_ptr  
	auto mp3Player = std::make_shared<MP3Player>();
	auto mp4Player = std::make_shared<MP4Player>();
	auto mp3File = std::make_shared<MP3File>();
	auto mp4File = std::make_shared<MP4File>();

	// 创建桥接对象并组合媒体播放器和媒体文件  
	auto mp3Bridge = std::make_shared<MediaBridge>(mp3Player, mp3File);
	auto mp4Bridge = std::make_shared<MediaBridge>(mp4Player, mp4File);

	// 使用桥接对象播放媒体文件  
	mp3Bridge->play(); // 输出: Opening MP3 file  
					   //       Playing MP3 file  
	mp4Bridge->play(); // 输出: Opening MP4 file  
					   //       Playing MP4 file  

	// 由于使用了shared_ptr，当main函数结束时，所有对象都会被自动删除  
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在这个例子中，MediaPlayer 和 MediaFile 是抽象接口，它们的实现类是独立的。通过使用桥接类 MediaBridge，可以动态地组合不同的媒体播放器和媒体文件，而不需要修改现有的类。这种设计降低了类之间的耦合度，因为添加新的媒体播放器或媒体文件类型只需要创建新的实现类，而不需要修改桥接类或其他现有类。这种灵活性使得系统更加易于维护和扩展。

3.3 桥接模式在处理多个独立变化维度的典型应用

在 C++ 中，桥接模式特别适用于处理多个独立变化维度的典型应用，如消息管理系统。在这样的系统中，消息的类型（如文本消息、图片消息、视频消息等）和消息的传输方式（如短信、电子邮件、即时消息等）是两个独立的变化维度。使用桥接模式，可以将这两个维度解耦，使得它们可以独立地扩展和修改。

以下是一个使用桥接模式实现消息管理系统的例子：

首先，定义抽象接口和具体实现：

// 消息接口  
class Message {
public:
	virtual void send() const = 0;
	virtual ~Message() = default;
};

// 消息传输方式接口  
class MessageSender {
public:
	virtual void send(const Message& msg) = 0;
	virtual ~MessageSender() = default;
};

// 文本消息类  
class TextMessage : public Message {
public:
	void send() const override {
		std::cout << "Sending text message..." << std::endl;
	}
};

// 图片消息类  
class ImageMessage : public Message {
public:
	void send() const override {
		std::cout << "Sending image message..." << std::endl;
	}
};

// 短信传输方式类  
class SMSSender : public MessageSender {
public:
	void send(const Message& msg) override {
		std::cout << "Sending message via SMS..." << std::endl;
		msg.send();
	}
};

// 电子邮件传输方式类  
class EmailSender : public MessageSender {
public:
	void send(const Message& msg) override {
		std::cout << "Sending message via Email..." << std::endl;
		msg.send();
	}
};
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

然后，创建桥接类来组合消息和传输方式：

// 消息桥接类  
class MessageBridge {
public:
	MessageBridge(std::shared_ptr<Message> message, std::shared_ptr<MessageSender> sender)
		: message(message), sender(sender) {}

	void send() {
		sender->send(*message);
	}

protected:
	std::shared_ptr<Message> message;
	std::shared_ptr<MessageSender> sender;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

最后，在客户端代码中，可以创建消息和传输方式的实例，并使用它们来初始化桥接对象：

int main() 
{
	// 创建消息对象  
	auto textMsg = std::make_shared<TextMessage>();
	auto imageMsg = std::make_shared<ImageMessage>();

	// 创建传输方式对象  
	auto smsSender = std::make_shared<SMSSender>();
	auto emailSender = std::make_shared<EmailSender>();

	// 创建桥接对象  
	auto textMsgSmsBridge = std::make_shared<MessageBridge>(textMsg, smsSender);
	auto imageMsgEmailBridge = std::make_shared<MessageBridge>(imageMsg, emailSender);

	// 发送消息  
	textMsgSmsBridge->send(); // 输出: Sending message via SMS...  
							  //       Sending text message...  
	imageMsgEmailBridge->send(); // 输出: Sending message via Email...  
								 //       Sending image message...  

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个例子中，消息类型和传输方式都是独立变化的维度。于是可以很容易地添加新的消息类型（如视频消息）或新的传输方式（如即时消息服务），而不需要修改现有的代码。桥接模式允许根据需要在运行时动态地组合不同的消息和传输方式，从而提供了很大的灵活性。

4 桥接模式的优点与缺点

桥接模式的优点主要包括：

（1）降低耦合性： 桥接模式将抽象部分与实现部分分离，使它们可以独立变化。这有助于降低类之间的耦合性，提高系统的灵活性和可扩展性。

（2）提高可重用性： 由于抽象部分和实现部分可以独立变化，因此可以重用已有的抽象部分或实现部分，而不需要对整个系统进行修改。

（3）支持多种实现方式： 一个抽象类可以有多个实现类，这意味着可以使用不同的实现方式来满足不同的需求。

（4）符合开闭原则： 桥接模式符合面向对象设计原则中的开闭原则，即对扩展开放，对修改封闭。这意味着当需要增加新的功能或实现时，可以通过增加新的实现类来实现，而不需要修改现有的代码。

然而，桥接模式也有一些缺点：

（1）增加系统复杂性： 桥接模式需要引入额外的抽象层，这可能会增加系统的复杂性。同时，如果滥用桥接模式，可能会导致系统结构变得过于复杂和难以维护。

（2）识别独立维度困难： 在桥接模式中，需要正确识别系统中的两个独立变化的维度。这可能需要一定的经验和技巧，如果识别不准确，可能会导致模式的应用效果不佳。

（3）编程难度增加： 由于桥接模式需要在抽象层进行设计和编程，因此可能会增加编程的难度。开发者需要熟悉并掌握桥接模式的原理和应用方法，才能有效地使用它。