实现一个内存池管理的类

喜欢ヅ旅行 2022-08-07 14:53 161阅读 0赞

模拟STL中的freelist,有这个思想在内。

union obj
    {
      union obj* next;
      char p[1];     
    };
    
    class MemoryPool
    { 
         public:
                MemoryPool()
                {
                   union obj* temp;
                   m_memory.assign(5,(union obj*)NULL);         
                   for(int i=0;i<m_memory.size();i++)
                   {
                       for(int j=0;j<m_memory.size();j++)
                       {
                         temp = (obj*)malloc(sizeof(char)*(1<<(i+3)));     
                         temp->next = m_memory[i];
                         m_memory[i] = temp; 
                       }
                   }
                }
                char* mem_get(int size)
                {
                   int j;
                   if( size > 128)
                   {
                      char* start = (char*)malloc(sizeof(char)*size);
                      return start; 
                   }
                   int index = freelist_index(size);
                   obj* temp = m_memory[index];
                   if(temp == NULL)  //
                   {
                      for(j = index+1;j<m_memory.size();j++)
                      {
                         temp = m_memory[j];
                         if(temp != NULL)
                         {
                           m_memory[j] = temp->next;
                           break;       
                         }     
                      }
                      if(j>= m_memory.size())
                      {
                         for(int j=0;j<m_memory.size();j++)
                        {
                          temp = (obj*)malloc(sizeof(char)*(1<<(index+3)));     
                          temp->next = m_memory[index];
                          m_memory[index] = temp; 
                        }  
                        temp = m_memory[index];
                        m_memory[index] = temp->next;
                        return (char*)temp;
                      }
                      else
                      {
                         obj* cur;
                        
                         int up_size = round_up(size);
                         for(int i=0;i<(1<<(j-index));i++)
                         {
                            cur =  temp;
                            cur->next = m_memory[index];
                            m_memory[index] = cur;
                            temp = cur+up_size;
                      
                         } 
                         temp = m_memory[index];
                         m_memory[index] = temp->next;
                         return (char*)temp;
                      }     
                   }
                   else
                   { 
                      m_memory[index] = temp->next;
                      return (char*)temp; 
                   }
                }
                void mem_free(void* p,int size)
                {
                  if(size > 128)
                  {
                    free(p);
                    return ;   
                  }   
                  obj* temp = (obj*)p;
                  int index = freelist_index(size);
                  temp->next = m_memory[index];
                  m_memory[index]  = temp;
                }
         private:
                 enum {_ALIGN = 8};//
                 int freelist_index(int __bytes) 
                 {
                     return (((__bytes) + (int)_ALIGN-1)/(size_t)_ALIGN - 1);
                 }
                 int round_up(int __bytes) 
                 { 
                   return (((__bytes) + (int) _ALIGN-1) & ~((int) _ALIGN - 1)); 
                 }
                 vector<union obj*> m_memory; 
          };