结构型模式 享元模式

结构型模式 享元模式

抽象享元角色:
        所有具体享元类的父类,规定一些需要实现的公共接口。
具体享元角色:
        抽象享元角色的具体实现类,并实现了抽象享元角色规定的方法。
享元工厂角色:
        负责创建和管理享元角色。

使用场景:
        是以共享的方式,高效的支持大量的细粒度的对象。

/**
 * 结构型模式 享元模式
 * Flyweight模式也叫享元模式,是构造型模式之一,它通过与其他类似对象共享数据来减小内存占用。
 *
 */

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <map>

class Person
{
public:
    Person(std::string name, int age, int sex)
    {
        m_name = name;
        m_age = age;
        m_sex = sex;
    }
    std::string getName()
    {
        return m_name;
    }
    int getAge()
    {
        return m_age;
    }
    int getSex()
    {
        return m_sex;
    }

protected:
    //注意: 保护属性变量
    std::string m_name;
    int m_age;
    int m_sex;
};

class Teacher: public Person
{
public:
    Teacher(std::string id, std::string name, int age, int sex): Person(name, age, sex)
    {
        m_id = id;
    }
    std::string getID()
    {
        return m_id;
    }
    void printT()
    {
        std::cout << "id: " << m_id << "\t" << "name: " << m_name << "\t" << "age: " << m_age << "\t" << "sex: " << m_sex  << std::endl;
    }
private:
    std::string m_id;
};

class TeacherFactory
{
public:
    TeacherFactory()
    {
        m_tpool.empty();
    }
    ~TeacherFactory()
    {
        while (!m_tpool.empty()) // 在工厂中创建老师结点,在工厂中销毁老师结点
        {
            Teacher *temp = nullptr;
            std::map<std::string, Teacher *>::iterator it = m_tpool.begin();
            temp = it->second;
            m_tpool.erase(it);
            delete temp;
        }
    }
    // 通过Teacher的pool,来存放老师结点,在TeacherFactory中创建老师、销毁老师
    Teacher *getTeacher(std::string tid)
    {
        std::string name;
        int age;
        int sex;

        Teacher *temp = nullptr;
        std::map<std::string, Teacher *>::iterator it = m_tpool.find(tid);
        if (it == m_tpool.end())
        {
            std::cout << "id为: " << tid << "的老师不存在, 系统为你创建该老师, 请输入以下信息" << std::endl;
            std::cout << "请输入老师的姓名: " << std::endl;
            std::cin >> name;
            std::cout << "请输入老师的年龄: " << std::endl;
            std::cin >> age;
            std::cout << "请输入老师的性别代号(1: 男 2: 女): " << std::endl;
            std::cin >> sex;
            temp = new Teacher(tid, name, age, sex);
            m_tpool.insert(std::pair<std::string, Teacher *>(tid, temp));
        }
        else
        {
            temp = it->second;
        }
        return temp;
    }
private:
    std::map<std::string, Teacher *> m_tpool;
};

void mytest()
{
    TeacherFactory *teacherFactory = new TeacherFactory();

    Teacher *t1 = teacherFactory->getTeacher("001");
    t1->printT();

    Teacher *t2 = teacherFactory->getTeacher("002");
    t1->printT();

    Teacher *t3 = teacherFactory->getTeacher("001");
    t1->printT();

    delete teacherFactory;
    teacherFactory = nullptr;

    return;
}

int main()
{
    mytest();

    system("pause");
    return 0;
}
时间: 2024-10-09 04:19:44

结构型模式 享元模式的相关文章

&quot;围观&quot;设计模式(17)--结构型之享元模式(Flyweight Pattern)

享元模式(英语:Flyweight Pattern)是一种软件设计模式.它使用共享物件,用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件:它适合用于当大量物件只是重复因而导致无法令人接受的使用大量内存.通常物件中的部分状态是可以分享.常见做法是把它们放在外部数据结构,当需要使用时再将它们传递给享元.----WIKIPEDIA 个人理解 共享,内存消耗大的时候应考虑对象的共享,共享对象可以减少对象的生成数量,这样可以减少内存的消耗,当一个对象和其他的对象存在共性且内容一致的时候,可以将共有

设计模式(结构型)之享元模式(Flyweight Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(结构型)之外观模式(Facade Pattern)>http://blog.csdn.net/yanbober/article/details/45476527 概述 当一个软件系统在运行时产生的对象数量太多,将导致运行代价过高,带来系统性能下降等问题.所以需要采用一

《精通Python设计模式》学习结构型之享元模式

这个我日常当中也没有用到过, 真的是游戏行业用得多些? 学习一下, 有个印象. import random from enum import Enum TreeType = Enum('TreeTye', 'apple_tree cherry_tree peach_tree') class Tree: pool = dict() def __new__(cls, tree_type): obj = cls.pool.get(tree_type, None) if not obj: obj = o

设计模式--组合模式&amp;享元模式&amp;桥梁模式

一.组合模式 组合模式也叫作部分-整体模式,其定义如下:将对象组合成树形结构以表示"部分"和"整体"的层次结构,使得用户对单个对象和组合对象的使用具有一致性. 组合模式的优点和使用场景 优点:1.节点增加和减少是非常自由和方便的,这也是树形结构的一大特点:2.所有节点,不管是分支节点还是叶子结点,不管是调用一个结点,还是调用一个结点群,都是非常方便的.使用场景:1.维护部分与整体的逻辑关系,或者动态调用整体或部分的功能接口,可以考虑使用组合模式.例如,非常多的操作系

Java设计模式(六)合成模式 享元模式

(十一)合成模式 Composite 合成模式是一组对象的组合,这些对象可以是容器对象,也可以是单对象.组对象允许包含单对象,也可以包含其他组对象,要为组合对象和单对象定义共同的行为.合成模式的意义是 保证客户端调用单对象与组合对象的一致性. class TreeNode{ private String name; private TreeNode parent; private Vector<TreeNode> children = new Vector<TreeNode>();

Java共享模式/享元模式(Flyweight模式)

Flyweight定义:避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类). 为什么使用共享模式/享元模式 面向对象语言的原则就是一切都是对象,但是如果真正使用起来,有时对象数可能显得很庞大,比如,字处理软件,如果以每个文字都作为一个对象,几千个字,对象数就是几千,无疑耗费内存,那么我们还是要"求同存异",找出这些对象群的共同点,设计一个元类,封装可以被共享的类,另外,还有一些特性是取决于应用(context),是不可共享的,这也Flyweight中两个重要概念内

第13章 结构型模式—享元模式

1. 享元模式(Flyweight Pattern)的定义 (1)运用共享技术高效地支持大量细粒度的对象 ①对象内部状态:数据不变且重复出现,这部分不会随环境变化而改变,是可以共享的. ②对象外部状态:数据是变化的,会随环境变化而改变,是不可以共享的. ③所谓的享元,就是把内部状态的数据分离出来共享,通过共享享元对象,可以减少对内存的占用.把外部状态分离出来,放到外部,让应用程序在使用的时候进行维护,并在需要的时候传递给享元对象使用. ④享元模式真正缓存和共享的是享元的内部状态,而外部状态是不被

设计模式(28)-----结构型模式-----享元模式

享元模式(Flyweight Pattern)主要用于减少创建对象的数量,以减少内存占用和提高性能.这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结构的方式. 享元模式尝试重用现有的同类对象,如果未找到匹配的对象,则创建新对象.我们将通过创建 5 个对象来画出 20 个分布于不同位置的圆来演示这种模式.由于只有 5 种可用的颜色,所以 color 属性被用来检查现有的 Circle 对象.这里只有5个对象的. 介绍 意图:运用共享技术有效地支持大量细粒度的对象. 主

java设计模式--结构型模式--享元模式

享元模式 概述 运用共享技术有效地支持大量细粒度的对象. 适用性 当都具备下列情况时,使用Flyweight模式: 1.一个应用程序使用了大量的对象. 2.完全由于使用大量的对象,造成很大的存储开销. 3.对象的大多数状态都可变为外部状态. 4.如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象. 5.应用程序不依赖于对象标识.由于Flyweight对象可以被共享,对于概念上明显有别的对象,标识测试将返回真值. 参与者 1.Flyweight 描述一个接口,通过这个接口flywe