《设计模式的艺术》笔记 - 享元模式

这篇具有很好参考价值的文章主要介绍了《设计模式的艺术》笔记 - 享元模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

介绍

        享元模式运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象,因此它又称为轻量级模式,是一种对象结构型模式。

实现

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>
#include <unordered_map>

class Flyweight {   // 享元抽象类
public:
    Flyweight(const std::string &in);
    virtual void operation(const std::string &out) = 0;

    const std::string &getMIn() const;

private:
    std::string m_in;
};

class ConcreteFlyweight : public Flyweight {    // 具体享元类
public:
    ConcreteFlyweight(const std::string &in);

    void operation(const std::string &out) override;
};

class FlyweightFactory {    // 配合工厂模式使用享元工厂类
public:
    ~FlyweightFactory();
    Flyweight *getFlyweight(const std::string &key);
private:
    std::unordered_map<std::string, Flyweight *> m_flyweights;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"

Flyweight::Flyweight(const std::string &in) {
    m_in = in;
}

const std::string &Flyweight::getMIn() const {
    return m_in;
}

ConcreteFlyweight::ConcreteFlyweight(const std::string &in) : Flyweight(in) {

}

void ConcreteFlyweight::operation(const std::string &out) {
    std::cout<< "内部状态: " << getMIn() << ", 外部状态: " << out << std::endl;
}

FlyweightFactory::~FlyweightFactory() {
    for (auto it : m_flyweights) {
        if (it.second) {
            delete it.second;
        }
    }
}

Flyweight* FlyweightFactory::getFlyweight(const std::string &key) {
    auto it = m_flyweights.find(key);
    if (it != m_flyweights.end()) {
        return it->second;
    } else {
        Flyweight *flyweight = new ConcreteFlyweight(key);
        m_flyweights.insert(std::make_pair(key, flyweight));
        return flyweight;
    }
}

main.cpp

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    FlyweightFactory *factory = new FlyweightFactory();
    auto fly1 = factory->getFlyweight("a");
    auto fly2 = factory->getFlyweight("b");
    auto fly3 = factory->getFlyweight("a");
    fly1->operation("1");
    fly2->operation("2");
    fly3->operation("3");

    delete factory;

    return 0;
}

总结

优点

        1. 可以极大减少内存中对象的数量,使得相同或相似对象在内存中只保存一份,从而可以节约系统资源,提高系统性能。

        2. 享元模式的外部状态相对独立,而且不会影响其内部状态,从而使得享元对象可以在不同的环境中被共享。

缺点

        1. 享元模式需要分离出内部状态和外部状态,从而使得系统变得复杂,这使得程序的逻辑复杂化。

        2. 为了使对象可以共享,享元模式需要将享元对象的部分状态外部化,而读取外部状态将使得运行时间变长。

适用场景

        1. 一个系统有大量相同或者相似的对象,造成内存的大量耗费。

        2. 对象的大部分状态都可以外部化,可以将这些外部状态传入对象中。

        3. 在使用享元模式时需要维护一个存储享元对象的享元池,而这需要耗费一定的系统资源。因此,在需要多次重复使用同一享元对象时才值得使用享元模式。

练习

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>
#include <unordered_map>

class Flyweight {   // 享元抽象类
public:
    Flyweight(const std::string &in);
    virtual void display(const std::string &out) = 0;

    const std::string &getMIn() const;

private:
    std::string m_in;
};

class PictureFlyweight : public Flyweight {    // 具体享元类
public:
    PictureFlyweight(const std::string &in);

    void display(const std::string &out) override;
};

class AnimationFlyweight : public Flyweight {    // 具体享元类
public:
    AnimationFlyweight(const std::string &in);

    void display(const std::string &out) override;
};

class VideoFlyweight : public Flyweight {    // 具体享元类
public:
    VideoFlyweight(const std::string &in);

    void display(const std::string &out) override;
};

class FlyweightFactory {    // 配合工厂模式使用享元工厂类
public:
    ~FlyweightFactory();
    Flyweight *getFlyweight(const std::string &key);
    static FlyweightFactory *getInstance();
private:
    FlyweightFactory();

    std::unordered_map<std::string, Flyweight *> m_flyweights;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"

Flyweight::Flyweight(const std::string &in) {
    m_in = in;
}

const std::string &Flyweight::getMIn() const {
    return m_in;
}

PictureFlyweight::PictureFlyweight(const std::string &in) : Flyweight(in) {

}

void PictureFlyweight::display(const std::string &out) {
    std::cout << out << ", " << getMIn() << std::endl;
}

AnimationFlyweight::AnimationFlyweight(const std::string &in) : Flyweight(in) {

}

void AnimationFlyweight::display(const std::string &out) {
    std::cout << out << ", " << getMIn() << std::endl;
}

VideoFlyweight::VideoFlyweight(const std::string &in) : Flyweight(in) {

}

void VideoFlyweight::display(const std::string &out) {
    std::cout << out << ", " << getMIn() << std::endl;
}

FlyweightFactory::FlyweightFactory() {

}

FlyweightFactory* FlyweightFactory::getInstance() {
    static FlyweightFactory *factory = new FlyweightFactory();
    return factory;
}

FlyweightFactory::~FlyweightFactory() {
    for (auto it : m_flyweights) {
        if (it.second) {
            delete it.second;
        }
    }
}

Flyweight* FlyweightFactory::getFlyweight(const std::string &key) {
    auto it = m_flyweights.find(key);
    if (it != m_flyweights.end()) {
        return it->second;
    } else {
        Flyweight *flyweight = nullptr;
        if (key == "图片") {
            flyweight = new PictureFlyweight(key);
        } else if (key == "动画") {
            flyweight = new AnimationFlyweight(key);
        } else if (key == "视频") {
            flyweight = new VideoFlyweight(key);
        }
        m_flyweights.insert(std::make_pair(key, flyweight));
        return flyweight;
    }
}

main.cpp文章来源地址https://www.toymoban.com/news/detail-805308.html

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    FlyweightFactory *factory = FlyweightFactory::getInstance();
    factory->getFlyweight("图片")->display("1");
    factory->getFlyweight("动画")->display("2");
    factory->getFlyweight("视频")->display("3");
    factory->getFlyweight("图片")->display("4");

    return 0;
}

到了这里,关于《设计模式的艺术》笔记 - 享元模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 《设计模式的艺术》笔记 - 命令模式

            命令模式将一个请求封装为一个对象,从而可用不同的请求对客户进行参数化;对请求排队或者记录请求日志,以及支持可撤销的操作。命令模式是一种对象行为模式,其别名为动作模式或事务模式。 myclass.h myclass.cpp main.cpp         只需要增加一个CommandQueue类即可

    2024年01月20日
    浏览(56)
  • 《设计模式的艺术》笔记 - 组合模式

            组合模式组合多个对象形成树形结构以表示具有“部分-整体”关系的层次结构。组合模式对单个对象(即叶子对象)和组合对象(即容器对象)的使用具有一致性,又可以称为“部分—整体”(Part-Whole)模式,它是一种对象结构型模式。 myclass.h myclass.cpp main.cpp  

    2024年01月19日
    浏览(45)
  • 《设计模式的艺术》笔记 - 装饰模式

            装饰模式动态地给一个对象增加一些额外的职责,就增加对象功能来说,装饰模式比生成子类实现更为灵活。装饰模式是一种对象结构型模式。  myclass.h myclass.cpp main.cpp         1. 对于扩展一个对象的功能,装饰模式比继承更加灵活性,不会导致类的个数急剧增加

    2024年01月19日
    浏览(51)
  • 《设计模式的艺术》笔记 - 桥接模式

            桥接模式将抽象部分与其实现部分分离,使它们都可以独立地变化。它是一种对象结构型模式,又称为柄体模式或接口模式 myclass.h myclass.cpp main.cpp         1. 分离抽象接口及其实现部分。桥接模式使用“对象间的关联关系”解耦了抽象和实现之间固有的绑定关系,

    2024年01月18日
    浏览(56)
  • 《设计模式的艺术》笔记 - 外观模式

            外观模式中外部与一个子系统的通信通过一个统一的外观角色进行,为子系统中的一组接口提供一个一致的入口。外观模式定义了一个高层接口,这个接口使得子系统更加容易使用。外观模式又称为门面模式,它是一种对象结构型模式。 myclass.h myclass.cpp main.cpp    

    2024年01月19日
    浏览(53)
  • 《设计模式的艺术》笔记 - 代理模式

            代理模式是给某一个对象提供一个代理,并由代理对象控制对原对象的引用。代理模式是一种对象结构型模式。 myclass.h myclass.cpp main.cpp         1. 代理模式能够协调调用者和被调用者,在一定程度上降低了系统的耦合度,满足迪米特法则。         2. 客户端可以

    2024年01月19日
    浏览(58)
  • 《设计模式的艺术》笔记 - 原型模式

            使用原型实例指定创建对象的种类,并且通过克隆这些原型创建新的对象。原型模式是一种对象创建型模式。 myclass.h myclass.cpp main.cpp         优点:         1. 当创建新的对象实例较为复杂时,使用原型模式可以简化对象的创建过程,通过复制一个已有实例可以提

    2024年01月19日
    浏览(41)
  • 《设计模式的艺术》笔记 - 建造者模式

            建造者模式将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。建造这模式是一种对象创建型模式。 myclass.h myclass.cpp main.cpp         优点:         1. 在建造者模式中,客户端不必知道产品内部组成的细节,将产品本身与产品的创建

    2024年01月16日
    浏览(40)
  • 《设计模式的艺术》笔记 - 单例模式

            单例模式优点是可以确保系统中只存在单个对象实例,缺点是不便扩展,一定程度上违背单一原则,既提供业务方法,又提供创建对象方法         在类加载的时候就创建好对象,获取对象时直接返回即可         在类加载的时候没有创建对象,第一次获取对象

    2024年02月02日
    浏览(44)
  • 《设计模式的艺术》笔记 - 简单工厂模式

            定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有相同的父类。因为在简单工厂模式中用于创建实例的方法是静态方法,因此简单工厂模式又被称为静态工厂方法模式,属于类创建型模式         将Factory合并到父类Product中,此时

    2024年01月16日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包