實現一個內存池管理的類

模擬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;   
      };  </pre><br />