桥接和享元模式（结构型设计模式）的 C++ 代码示例模板

文章目录

前言
代码仓库
桥接模式（Bridge）
享元模式（Flyweight）
总结
参考资料
作者的话

前言

桥接和享元模式（结构型设计模式）的 C++ 代码示例模板。

代码仓库

yezhening/Programming-examples: 编程实例 (github.com)
Programming-examples: 编程实例 (gitee.com)

桥接模式（Bridge）

结构

抽象实现类
具体实现类
抽象抽象类
具体抽象类
桥接过程1：抽象抽象类封装（保护权限）抽象实现指针（实际上指向一个具体实现对象）
桥接过程2：形式上调用抽象的方法；实际上调用抽象的内容 + 实现的方法

重点理解

多维结构
合成聚合原则（C/ARP），聚合/组合关系
拆分抽象内容和实现内容，使用聚合/组合关系桥接
抽象内容：不是指抽象类和接口，指一个独立维度/类层次，如手机品牌类
实现内容：不是指具体类和实现类，指一个独立维度/类层次，如手机软件类
聚合/组合关系：手机品牌对象封装相关的手机软件对象
桥接方式：手机品牌对象通过手机软件对象使用手机软件类的属性和方法，不必知道手机软件类的状态和行为
无桥接方式（使用继承关系）：每个手机品牌类继承相关的手机软件类，类的数量呈树状结构几何递增，难以维护

代码

#include <iostream>using std::cout;
using std::endl;// 抽象实现类
class AbstractImplementation
{
public:virtual void impl_func() = 0;
};// 具体实现类 A
class ConcreteImplementationA : public AbstractImplementation
{
public:void impl_func() override{cout << "ConcreteImplementationA" << endl;return;}
};// 具体实现类 B
class ConcreteImplementationB : public AbstractImplementation
{
public:void impl_func() override{cout << "ConcreteImplementationB" << endl;return;}
};// 抽象抽象类
// 桥接过程1：抽象抽象类 封装（保护权限） 抽象实现指针（实际上指向一个具体实现对象）
class AbstractAbstraction
{
public:AbstractAbstraction(AbstractImplementation *abst_impl) : abst_impl(abst_impl) {}~AbstractAbstraction(){delete this->abst_impl;}virtual void abst_func() = 0;protected:AbstractImplementation *abst_impl;
};// 具体抽象类 A
class ConcreteAbstractionA : public AbstractAbstraction
{
public:ConcreteAbstractionA(AbstractImplementation *abst_impl) : AbstractAbstraction(abst_impl) {}// 桥接过程2：void abst_func() override // 形式上调用 抽象的方法{cout << "ConcreteAbstractionA" << endl; // 实际上调用 抽象的内容+ 实现的方法this->abst_impl->impl_func();           // + 实现的方法return;}
};// 具体抽象类 B
class ConcreteAbstractionB : public AbstractAbstraction
{
public:ConcreteAbstractionB(AbstractImplementation *abst_impl) : AbstractAbstraction(abst_impl) {}void abst_func() override{cout << "ConcreteAbstractionB" << endl;this->abst_impl->impl_func();return;}
};// 客户端
int main()
{// 具体实现 A 对象AbstractImplementation *abst_impl_A = new ConcreteImplementationA();// 具体抽象 A 对象AbstractAbstraction *abst_abst_A = new ConcreteAbstractionA(abst_impl_A); // 桥接抽象内容 A 和实现内容 Aabst_abst_A->abst_func();delete abst_abst_A; // delete abst_impl_AAbstractImplementation *abst_impl_B = new ConcreteImplementationB();AbstractAbstraction *abst_abst_B = new ConcreteAbstractionB(abst_impl_B);abst_abst_B->abst_func();delete abst_abst_B; // delete abst_impl_Breturn 0;
}
/*
输出：
ConcreteAbstractionA
ConcreteImplementationA
ConcreteAbstractionB
ConcreteImplementationB
*/

享元模式（Flyweight）

享元即共享

结构

抽象享元类
具体享元类（需要共享的内容）
具体不共享类（不需要共享的内容）
享元工厂类
内部状态（需要共享的内容）：对象的不变状态，可以被多个对象共享，不取决于外部环境，通常存储在具体享元对象内部
外部状态（不需要共享的内容）：对象的可变状态，不可以被多个对象共享，取决于外部环境，需要时作为参数传递给具体享元/具体不共享对象
具体享元类有内部状态，可以有外部状态
具体不共享类没有内部状态，有外部状态
享元工厂封装享元集合（实际上封装具体享元对象）（具体享元对象是共享的，具有共性，可以用工厂/集合统一管理；具体不共享对象是不共享的，不具有共性，一般不统一管理，需要时再创建）
享元工厂获取抽象享元指针（实际上指向一个具体享元对象）
享元工厂获取抽象享元指针（实际上指向一个具体不共享对象）

重点理解

具体不共享类和外部状态（不需要共享的内容）
具体享元类和内部状态（需要共享的内容）
具体享元对象和内部状态是共享的，从享元工厂创建或获取（无时创建，有时获取）
具体不共享对象和外部状态是不共享的，从享元工厂创建（需要时创建）

代码

#include <iostream>
#include <unordered_map>using std::cout;
using std::endl;
using std::pair;
using std::unordered_map;// 抽象享元类
class AbstractFlyweight
{
public:virtual void func(int external_state) = 0;// 外部状态（不需要共享的内容）：对象的可变状态，不可以被多个对象共享，取决于外部环境，需要时作为参数传递给具体享元/具体不共享对象
};// 具体享元类（需要共享的内容）
// 具体享元类 有内部状态，可以 有外部状态
class ConcreteFlyweight : public AbstractFlyweight
{
public:ConcreteFlyweight(int internal_state) : internal_state(internal_state) {}void func(int external_state) override{cout << "external_state: " << external_state << endl;cout << "internal_state: " << this->internal_state << endl;}private:int internal_state;// 内部状态（需要共享的内容）：对象的不变状态，可以被多个对象共享，不取决于外部环境，通常存储在具体享元对象内部
};// 具体不共享类（不需要共享的内容）
// 具体不共享类 没有内部状态，有外部状态
class ConcreteUnshared : public AbstractFlyweight
{
public:void func(int external_state) override{cout << "external_state: " << external_state << endl;}
};// 享元工厂
class FlyweightFactory
{
public:// 统一析构~FlyweightFactory(){for (pair<int, AbstractFlyweight *> p : this->flyweight_unmap){delete p.second;}}// 享元工厂 获取抽象享元指针（实际上指向一个具体享元对象）AbstractFlyweight *get_concrete_flyweight(int key){// 若不存在创建if (this->flyweight_unmap.find(key) == this->flyweight_unmap.end()){this->flyweight_unmap[key] = new ConcreteFlyweight(key);}// 若存在返回return this->flyweight_unmap[key];}// 享元工厂 获取抽象享元指针（实际上指向一个具体不共享对象）AbstractFlyweight *get_concrete_unshared(){return new ConcreteUnshared();}private:unordered_map<int, AbstractFlyweight *> flyweight_unmap;// 享元工厂 封装 享元集合（实际上 封装 具体享元对象）// 具体享元对象是共享的，具有共性，可以用工厂/集合统一管理// 具体不共享对象是不共享的，不具有共性，一般不统一管理，需要时再创建
};// 客户端
int main()
{// 享元工厂对象FlyweightFactory flyweight_factory;// 抽象享元指针（实际上指向具体享元对象）AbstractFlyweight *concrete_flyweight_1 = flyweight_factory.get_concrete_flyweight(10); // 设置内部状态concrete_flyweight_1->func(100);                                                        // 传递外部状态AbstractFlyweight *concrete_flyweight_2 = flyweight_factory.get_concrete_flyweight(10); // 获取同一个具体享元对象，共享的体现concrete_flyweight_2->func(200);                                                        // 不共享的体现// 抽象享元指针（实际上指向具体不共享对象）AbstractFlyweight *concrete_unshared = flyweight_factory.get_concrete_unshared();concrete_unshared->func(300); // 传递外部状态；不共享的体现delete concrete_unshared; // 显式析构具体不共享对象// 析构享元工厂对象时 隐式析构享元对象return 0;
}
/*
输出：
external_state: 100
internal_state: 10
external_state: 200
internal_state: 10
external_state: 300
*/