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

2023-12-21 10:32:43

前言

桥接和享元模式(结构型设计模式)的 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
*/

总结

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


参考资料


作者的话

  • 感谢参考资料的作者/博主
  • 作者:夜悊
  • 版权所有,转载请注明出处,谢谢~
  • 如果文章对你有帮助,请点个赞或加个粉丝吧,你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方,请留言,定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获

文章来源:https://blog.csdn.net/m0_62083249/article/details/135104760
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。