研发三维GIS系统笔记/框架改造/智能指针重构框架-003

1.　使用智能指针重构系统

　　原有的系统都是裸指针，在跨模块与多线程中使用裸指针管理起来很麻烦，尤其是多任务系统中会出现野指针

　　

class CELLTileTask :public CELLTask
{
public:
   　　CELLQuadTree*   _node;
    　 TileId          _tileId;
   　　CELLImage       _image;
};

任务队列中存储了 CELLQuadTree* _node; 在频繁或者剧烈操作相机的情况下，造成大量的瓦片任务，同时瓦片任务中存储的对四叉树对象已经被释放

在进行使用的过程中，就会出现野指针，为了避免这些问题，引入智能指针来解决对象的生命周期的问题。避免野指针的出现。

2.　　基类对象改造

　　基类对象是被引擎中的所有其他的类继承使用，所以先改造基类，从基类开始支持智能指针。

    class   CELLObject :public std::enable_shared_from_this<CELLObject>
    {
    public:
        using   ObjectPtr   =   std::shared_ptr<CELLObject>;
    public:
        CELLObject()
        {}
        virtual ~CELLObject()
        {}
        ObjectPtr   ptr()
        {
            return  shared_from_this();
        }
        
        template<class T>   
        std::shared_ptr<T>  toPtr()
        {
            return std::dynamic_pointer_cast<T>(ptr());
        }
    };

好处1，std::enable_shared_from_this<CELLObject> 这一句很重要，这样对象中继承了智能指针中的引用计数对象，降低访存次数，提升效率
好处2：可以实现智能指针与裸指针的相互转化，可以从裸指针转换成智能指针。

3.　　改造代码
　　引擎中四叉树节点
　　

using   NodePtr =   std::shared_ptr<CELLQuadTree>;

 

class   CELLQuadTree :public CELLObject
    {
    public:
        enum ChildId
        {
            CHILD_LT,
            CHILD_RT,
            CHILD_LB,
            CHILD_RB,
        };
        enum 
        {
            FLAG_HAS_IMAGE  =   1<<0,
            FLAG_HAS_CULL   =   1<<1,
            FLAG_RENDER     =   1<<2,
        };
    public:
        typedef std::vector<CELLQuadTree*>  ArrayNode;
        typedef CELLTerrainInterface        TerrainApi;
        using   NodePtr =   std::shared_ptr<CELLQuadTree>;
    public:
        TerrainApi*     _terrain;
        /// 数据标志
        uint            _flag;
        /// 对应瓦片id
        TileId          _tileId;
        real2           _vStart;
        real2           _vEnd;

        float2          _uvStart;
        float2          _uvEnd;
        /// 对应瓦片的范围(世界坐标)
        aabb3dr         _aabb;
        /// 位置
        ChildId         _cornerId;
        /// 当前瓦片的父节点，这里不能使用智能指针，否则会造成相互引用，造成智能指针无法释放(相互依赖引用)
        CELLQuadTree*   _parent;
        /// 瓦片的孩子节点,注意这里，使用了智能指针
        NodePtr         _childs[4];
        /// 纹理id
        uint            _textureId;
};

4.　　节点示释放代码，不在使用delete 操作

for (int i = 0 ;i < 4 ; ++ i)
{
     _childs[i]  =   nullptr;
}

5. 　　任务系统改造，使用智能指针对象

    class   CELLTask :public CELLObject
    {
    public:
        CELLTask()
        {}
        virtual ~CELLTask()
        {}
    };

    using   TaskPtr     =   std::shared_ptr<CELLTask>;

 

6.　　任务对象

 class   CELLTaskSystem
    {
    public:
        class   TaskThread :public CELLThread
        {
        public:
            bool            _exitFlag;
            CELLTaskSystem* _system;
        public:
            TaskThread(CELLTaskSystem* pSystem)
            {
                _system     =   pSystem;
                _exitFlag   =   true;
            }
        public:
            virtual void    join()
            {
                _exitFlag   =   true;
                CELLThread::join();

            }
            virtual bool    onCreate()
            {
                _exitFlag   =   false;
                return  false;
            }
            virtual bool    onRun()
            {
                while (!_exitFlag)
                {
                    _system->run();
                }
                return  false;
            }
            virtual bool    onDestroy()
            {
                return  false;
            }
        };

        typedef std::vector<CELLThread*>    ArrayThread;
        typedef std::list<TaskPtr>          ArrayTask;
    public:
        CELLTaskObserver*   _observer;
        ArrayThread         _threads;
　　　　　　 /// 这里使用智能指针队列，而不是裸指针
        ArrayTask           _tasks;
        CELLSemaphore       _semphore;
        CELLMutex           _mutex;
}；