c/c++设计模式---享元模式

标签：享元 设计模式 对象 --- nmsp2 nmsp1 Position Piece

引入享元模式：

围棋游戏：

namespace _nmsp1
{
    enum EnumColor //棋子类型
    {
        Black, //黑
        White  //白
    };
    struct Position //棋子位置
    {
        int m_x;
        int m_y;
        Position(int tmpx, int tmpy) :m_x(tmpx), m_y(tmpy) {} //构造函数            
    };
    class Piece //棋子
    {
    public:
        Piece(EnumColor tmpcolor, Position tmppos) :m_color(tmpcolor), m_pos(tmppos) {} //构造函数

        void draw() //棋子的绘制
        {
            if (m_color == Black)
            {
                cout << "在位置：（" << m_pos.m_x << "，" <<  m_pos.m_y << "）处绘制了一个黑色棋子！" << endl;
                //....这里可以是一系列用于具体绘制的代码
            }
            else
            {
                cout << "在位置：（" << m_pos.m_x <<  "，" << m_pos.m_y << "）处绘制了一个白色棋子！" << endl;
                //....这里可以是一系列用于具体绘制的代码
            }
        }
    private:
        EnumColor m_color; //棋子颜色
        Position m_pos; //棋子位置
    };

    
}
int main()
{

std::list<_nmsp1::Piece*> piecelist; 

    _nmsp1::Piece* p_piece1 = new _nmsp1::Piece(_nmsp1::Black, _nmsp1::Position(3, 3)); //黑色落子到3,3位置
    p_piece1->draw();

    _nmsp1::Piece* p_piece2 = new _nmsp1::Piece(_nmsp1::White, _nmsp1::Position(5, 5)); //白色落子到5,5位置
    p_piece2->draw();

    _nmsp1::Piece* p_piece3 = new _nmsp1::Piece(_nmsp1::Black, _nmsp1::Position(4, 6)); //黑色落子到4,6位置
    p_piece3->draw();

    _nmsp1::Piece* p_piece4 = new _nmsp1::Piece(_nmsp1::White, _nmsp1::Position(5, 7)); //白色落子到5,7位置
    p_piece4->draw();
    //.....


    piecelist.push_back(p_piece1);
    piecelist.push_back(p_piece2);
    piecelist.push_back(p_piece3);
    piecelist.push_back(p_piece4);


    //释放资源
    delete p_piece1;
    delete p_piece2;
    delete p_piece3;
    delete p_piece4;


}

 

享元模式实现：

 

namespace _nmsp2
{
    enum EnumColor //棋子类型
    {
        Black, //黑
        White  //白
    };
    struct Position //棋子位置
    {
        int m_x;
        int m_y;
        Position(int tmpx, int tmpy) :m_x(tmpx), m_y(tmpy) {} //构造函数            
    };

    class Piece //棋子抽象类
    {
    public:
        virtual ~Piece() {} //做父类时析构函数应该为虚函数
    public:
        virtual void draw(Position tmppos) = 0;
    };

    class BlackPiece :public Piece //黑色棋子
    {
    public:
        //int ins;
        virtual void draw(Position tmppos)
        {
            cout << "在位置：（" << tmppos.m_x << "，" << tmppos.m_y << "）处绘制了一个黑色棋子！" << endl;
            //....这里可以是一系列用于具体绘制的代码
        }
    };

    class WhitePiece :public Piece //白色棋子
    {
    public:
        virtual void draw(Position tmppos)
        {
            cout << "在位置：（" << tmppos.m_x << "，" << tmppos.m_y << "）处绘制了一个白色棋子！" << endl;
            //....这里可以是一系列用于具体绘制的代码
        }
    };

    class pieceFactory //创建棋子的工厂
    {
    public:
        virtual ~pieceFactory() 
        {
            //释放内存
            for (auto iter = m_FlyWeightMap.begin(); iter != m_FlyWeightMap.end(); ++iter)
            {
                Piece* tmpfw = iter->second;
                delete tmpfw;
            }
            m_FlyWeightMap.clear(); //可有可无
        }

        Piece* getFlyWeight(EnumColor tmpcolor) //获取享元对象，也就是获取被共享的棋子对象
        {
            auto iter = m_FlyWeightMap.find(tmpcolor);
            if (iter == m_FlyWeightMap.end())
            {
                //没有该享元对象，那么就创建出来
                Piece* tmpfw = nullptr;
                if (tmpcolor == Black) //黑子
                {
                    tmpfw = new BlackPiece();
                }
                else //白子
                {
                    tmpfw = new WhitePiece();
                }
                m_FlyWeightMap.insert(make_pair(tmpcolor, tmpfw)); //以棋子颜色枚举值作为key，增加条目到map中
                return tmpfw;
            }
            else
            {
                return iter->second;
            }
        }

    private:
        std::map<EnumColor, Piece*> m_FlyWeightMap; //享元池，用map容器来保存所有的享元对象，一共就两个享元对象（黑色棋子一个，白色棋子一个）
    };

}

int main()
{

_nmsp2::pieceFactory* pfactory = new _nmsp2::pieceFactory();

    _nmsp2::Piece* p_piece1 = pfactory->getFlyWeight(_nmsp2::Black);
    p_piece1->draw(_nmsp2::Position(3, 3));  //黑子落子到3,3位置

    _nmsp2::Piece* p_piece2 = pfactory->getFlyWeight(_nmsp2::White);
    p_piece2->draw(_nmsp2::Position(5, 5));  //白子落子到5,5位置

    _nmsp2::Piece* p_piece3 = pfactory->getFlyWeight(_nmsp2::Black);
    p_piece3->draw(_nmsp2::Position(4, 6));  //黑子落子到4,6位置

    _nmsp2::Piece* p_piece4 = pfactory->getFlyWeight(_nmsp2::White);
    p_piece4->draw(_nmsp2::Position(5, 7));  //白子落子到5,7位置


    //释放资源
    delete  pfactory;
    
    return 0;

}

     享元（Flyweight）模式:蝇量模式，结构型模式，解决的是面向对象程序设计的性能问题     //享元：被共享的单元或者被共享的对象。Flyweight——轻量级（占用的内存更少）。     //设计思想：当需要某个对象时，尽量共用已经创建出的同类对象从而避免频繁使用new创建同类或者相似的对象。     //（1）从一个典型的范例开始     //享元对象（被共享的对象）：黑棋，白棋     //（2）引入享元（Flyweight）模式     //该模式避免了程序中出现大量相同或者相似的对象，通过共享对象的方式实现相似对象的重用。     //定义：运用共享技术有效地支持大量细粒度的对象（的复用）。
    //内部状态：存储在享元对象内部，一直不会发生改变的状态。这种状态可以被共享。     //外部状态：随着外部环境和各种动作因素的改变而发生改变的状态，这种状态不可以被共享。     //     //享元模式的目的：减少对象数量，节省内存，提高程序运行效率。
    //三种角色：     //a)Flyweight(抽象享元类）：Piece类     //b)ConcreteFlyweight（具体享元类）：BlackPiece、WhitePiece。     //c)FlyWeightFactory（享元工厂类）：pieceFactory
    //使用情形：     //a)程序中有大量相同或者相似对象造成内存大量消耗。     //b)对象的大部分状态都是或者都可以转变成外部状态，通过参数传入到对象中。     //c)享元池的引入增加了程序实现的复杂性，当然也有一定内存开销，使用享元模式要衡量性价比。
    //不要将享元模式  对象池，连接池，线程池等混为一谈。

享元模式是一种结构型设计模式，旨在减少应用程序中相似对象的内存使用或计算成本，通过共享相同状态的对象实例来达到节省资源的目的。在享元模式中，共享的对象被称为“享元”，而对于不同的上下文或情境，可以通过在享元对象中维护外部状态来实现个性化。

这个模式的关键思想是将对象的状态分为内部状态和外部状态。内部状态是对象共享的部分，存储在享元对象内部；而外部状态是对象可变的部分，需要在运行时由客户端传递给享元对象。通过这种方式，可以在不同的上下文中重用相同的享元对象，从而节省内存和提高性能。

享元模式通常与工厂模式结合使用，以便动态创建和管理享元对象。这种模式在需要大量相似对象时特别有用，例如图形编辑器中的图形对象，游戏中的粒子效果，或者操作系统中的字体对象。

 

下面是一个简单的 C++ 代码示例，演示了如何使用享元模式来共享相同状态的对象实例：

#include <iostream>
#include <unordered_map>

// 享元对象类
class Flyweight {
public:
    virtual void operation(int extrinsicState) = 0;
};

// 具体享元对象类
class ConcreteFlyweight : public Flyweight {
public:
    void operation(int extrinsicState) override {
        std::cout << "具体享元对象操作，外部状态：" << extrinsicState << std::endl;
    }
};

// 享元工厂类
class FlyweightFactory {
private:
    std::unordered_map<std::string, Flyweight*> flyweights;

public:
    Flyweight* getFlyweight(std::string key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = new ConcreteFlyweight();
        }
        return flyweights[key];
    }
};

int main() {
    FlyweightFactory factory;
    
    Flyweight* fw1 = factory.getFlyweight("key1");
    fw1->operation(1);
    
    Flyweight* fw2 = factory.getFlyweight("key2");
    fw2->operation(2);
    
    Flyweight* fw3 = factory.getFlyweight("key1");
    fw3->operation(3); // 复用了fw1对应的享元对象
    
    return 0;
}

在这个例子中，ConcreteFlyweight 是具体的享元对象类，实现了 Flyweight 接口。FlyweightFactory 是享元工厂类，负责创建和管理享元对象。在 main 函数中，演示了如何通过享元工厂获取共享的享元对象，并传递外部状态进行操作。由于重复使用了相同的 key，可以看到第一个和第三个操作使用了同一个享元对象。

这里只是一个简单的示例，实际应用中可能会更复杂，需要根据具体情况来设计和实现享元模式。

 

标签：享元,设计模式,对象,---,nmsp2,nmsp1,Position,Piece
From： https://www.cnblogs.com/bwbfight/p/18228403