前言

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

代码仓库

桥接模式（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 和实现内容 A
    abst_abst_A->abst_func();
    delete abst_abst_A; // delete abst_impl_A

    AbstractImplementation *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_B

    return 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
*/