桥接模式

news2025/6/2 12:23:28

在玩游戏的时候我们常常会遇到这样的机制：我们可以随意选择不同的角色，搭配不同的武器。这时只有一个抽象上下文的策略模式就不那么适用了，因为一旦我们使用继承的方式，武器和角色总有一方会变得难以扩展。这时，我们就需要通过组合来连接二者，这种连接的设计模式叫做桥接模式（Bridge）。

简介

定义：将抽象与实现部分分离，使它们都可以独立地变化。是一种对象结构型模式，又称为柄体（Handle and Body）模式或接口（Interface）模式。

使用场景：对象的结构可以分为多个维度，而且每个维度需要能够独立变化和扩展。

那么问题来了，何谓“抽象”与“实现”的分离呢？

抽象（Abstraction）：指隐藏复杂的内部细节，仅对外暴露必要的接口或功能的做法。C++中通常通过三种方式实现。（1）抽象类：就是包含纯虚函数的类，没有办法被实例化，仅仅定义接口。（2）接口：在C++里的接口就是通过纯虚函数类模拟的。（3）封装：通过私有域和保护域隐藏数据，公共域提供访问方法。

实现（Implementation）：实现就是抽象的具体化。因为”抽象“中的接口还只是一个规范，没有具体的行为，所以”实现“就是实现接口背后实际的代码逻辑。

还记得策略模式中的抽象策略类和具体策略类吗？

/*抽象策略类*/
class AttackStrategy {
public:
virtual ~AttackStrategy(){}
//重击接口
virtual void thump() = 0;
//技能接口
virtual void skill() = 0;
};
/*具体策略类*/
//劈棍
class PiGun : public AttackStrategy {
public:
void thump() override {
		cout << "腾空而起，高举棍子，向你劈去。" << endl;
	}
void skill() override {
		cout << "破棍式！斩棍式！" << endl;
	}
	~PiGun() {};
};

没错，策略模式通过“继承”的方式将抽象与实现分离了。为了让各种实现逻辑灵活切换，策略模式没有把实现的逻辑封装在策略类中，而是将“实现”分离出此类，而类本身通过提供一个接口让“抽象”与“实现”通过继承的关系联系起来。

而策略模式作为行为型模式，注重的是行为的动态替换，并不在意“抽象”层次的变化。而桥接模式作为关注抽象与实现都能独立变化的结构型模式，它在分离抽象与实现时不通过继承关系关联二者，而是通过组合关系。

通俗的说，我如果是法师职业的“角色”，其实只是我用法杖这个“武器”有加成，我也可以用剑的（近战法师）。那么“用法杖攻击”和“用剑攻击”的行为就是”实现“。我的法师职业或替换为战士职业的“角色"就是提供接口的”抽象“。为了我可以随意搭配，我就需要把抽象和实现分离，再通过组合关联起来（可以看下文的代码理解）。

桥接模式有以下4个关键角色：

1、抽象：代表着“抽象”层次，定义抽象接口，持有“实现”层次的引用或指针。

2、扩展抽象：“扩展”意为对抽象的细化，比如添加角色的专属逻辑需要，是更具的的抽象，仍然是抽象层次的一部分。通常是抽象类的子类或具体实现类。

3、实现：代表着“实现”层次，定义实现接口。

4、具体实现：提供实现的具体逻辑。

但话又说回来，抽象接口和实现接口又是什么？简单来说他们分别是抽象和实现层次的一部分，抽象接口顾名思义就是抽象的，它不需要实现具体的功能，只需要把操作委托给实现接口就好了。也就是说抽象接口是依赖于实现接口的，从而解耦变化维度。

class Character {  //抽象接口
protected:
    Weapon* weapon;  //实现接口（的指针）
public:
    //这里暂时省略扩展抽象
    void fight() const { 
        weapon->use();  //操作委托给实现接口
    }
};

实现

那么现在就用C++代码模拟上文中我们说到的角色与武器搭配，演示一下传说中的桥接模式罢！

首先我们先要确定，“角色”和“武器”这两个维度谁来做抽象层还有谁来做实现层。这时，我们就要区分谁适合做结构的高层或者控制层。仔细一想，武器是决定行为方式的，角色是持有武器的，那理所应当角色可以适合充当控制层，即抽象维度为“角色”，实现维度为“武器”。

姑且设定角色可以有战士和法师，武器有剑和法杖。他们分别作为子类充当扩展抽象角色以及具体实现角色。理清结构之后就可以开始写下代码了。

#include <iostream>
using namespace std;
//把实现层次放在抽象层次的前面，因为抽象需要用到实现的方法
/*----实现层次----*/
/*实现*/
class Weapon {
public:
virtual ~Weapon() {}
//提供使用武器的接口（实现接口）
virtual void use() const = 0;
};
/*具体实现*/
//剑
class Sword : public Weapon {
public:
void use() const override {
		cout << "接招吧，雷霆半月斩！" << endl;
	}
};
//法杖
class Staff : public Weapon {
public:
void use() const override {
		cout << "接招吧，圣灵魔闪光！" << endl;
	}
};
/*----抽象层次----*/
/*抽象*/
class Character {
//设置指针为保护成员，这样一来派生类可以直接访问实现层
protected:
//此处封装“实现”的指针，这是桥接的核心，即组合
	Weapon* weapon;
public:
//explicit抑制类型转换关键字
explicit Character(Weapon* weapon) : weapon(weapon){}
virtual ~Character() {
delete weapon;//释放桥接的指针
	}
//提供战斗的接口（抽象接口）
virtual void fight() const = 0;
};
/*扩展抽象（即具体角色）*/
//战士
class Warrior : public Character {
public:
//委托构造
explicit Warrior(Weapon* weapon) : Character(weapon) {}
void fight() const override {
		cout << "哈哈哈，吾乃帝国名扬四海的狂战士：";
		weapon->use();
	}
};
//法师
class Mage : public Character {
public:
//委托构造
explicit Mage(Weapon* weapon) : Character(weapon) {}
void fight() const override {
		cout << "哈哈哈，吾乃教会首屈一指的魔法使：";
		weapon->use();
	}
};
int main() {
//新建角色
	Character* c = new Warrior(new Sword);
	c->fight();
delete c;
	c = new Mage(new Sword);
	c->fight();
delete c;
	c = new Warrior(new Staff);
	c->fight();
delete c;
	c = new Mage(new Staff);
	c->fight();
delete c;	
return 0;
}

当然，如果我们遇到多个维度而非上述两个维度的情况，可以考虑使用“嵌套桥接”。

class Character {
protected:
	Weapon* weapon;
//防具指针
	Armor* armor;
public:
//explicit抑制类型转换关键字
explicit Character(Weapon* weapon, Armor* armor) : weapon(weapon), armor(armor){}
virtual ~Character() {
delete weapon;//释放桥接的指针
delete armor;
	}
virtual void fight() const = 0;
};
class Warrior : public Character {
public:
explicit Warrior(Weapon* weapon) : Character(weapon) {}
void fight() const override {
		cout << "哈哈哈，吾乃帝国名扬四海的狂战士：";
		weapon->use();
		armor->defend();
	}
};