void *cOBJ_Sprite::operator new(size_t size) throw()
{
  if(size != sizeof(cOBJ_Sprite))
  {
    return ::operator new(size);
  }
  
  cOBJ_Sprite *ptr = m_begin;
  
  // If the memory has already been allocated return the first
  // pointer on the list, if not then allocate the memory needed.
  if(ptr)
  {
    m_begin = ptr->m_next;
  }
  else
  {
    new_handler golbalHandler = std::set_new_handler(m_newHandler);
    
    // Allocate sizeof(cOBJ_Sprite) * OBJ_TOTALSPRITES bytes
    cOBJ_Sprite *block;
    try 
    {
      block = static_cast<cOBJ_Sprite*>(::operator new(
        sizeof(cOBJ_Sprite) * OBJ_TOTALSPRITES));
    }
    catch(std::bad_alloc&)
    {
      std::set_new_handler(golbalHandler);
      throw;
    }
    std::set_new_handler(golbalHandler);
    
    // Link the memory together starting with 1 because we will
    // return the zeroith pointer to the calling object.
    for(int i = 1; i < OBJ_TOTALSPRITES-1; i++)
    {
      block.m_next = &block[i+1];
    }
    block[OBJ_TOTALSPRITES-1].m_next = 0;
    
    ptr = block;
    
    m_begin = &block[1];
  }
  
  return ptr;
} // operator new

#include <loki/Singleton.h>#include <boost/pool/pool.hpp>#include <boost/pool/pool_alloc.hpp>#include <boost/shared_ptr.hpp>#include <cstddef>#include <hash_map>class Object {   typedef size_t					size_type;   typedef boost::pool< >				pool_type;   typedef boost::shared_ptr<pool_type>			pool_ptr;   typedef std::pair<const size_type, pool_ptr>		pool_pair;   typedef boost::fast_pool_allocator<pool_pair>	pool_alloc;   typedef stdext::hash_map<				size_type, pool_ptr,				stdext::hash_compare<size_t>,				pool_alloc			    >	mmap;   typedef Loki::SingletonHolder< mmap, Loki::CreateStatic, Loki::PhoenixSingleton > PoolMap;public:    void* operator new(size_t n) {        mmap& m = PoolMap::Instance();        mmap::const_iterator itr =  m.find(n);        if(itr != m.end())            return itr->second->ordered_malloc();        else {            pool_ptr pp(new pool_type(n));            m[n] = pp;            return pp->ordered_malloc();	}    }    void operator delete(void* p, size_t n) {        	mmap& m = PoolMap::Instance();        mmap::const_iterator itr =  m.find(n);        if(itr == m.end())	   return ;        if(!itr->second->is_from(p))	   return ;        itr->second->ordered_free(p);    }};

struct foo : public Object {   int i;   foo(int j): i(j) {}};#include <string>struct bar : public Object {   typedef std::basic_string<				char,				std::char_traits<char>,				boost::pool_allocator<char>			     >	string_type;   string_type s;   bar(const string_type& s_ = string_type()): s(s_) {}};#include <iostream>int main() {   for(int i = 0; i < 1000000; ++i) {	foo* f = new foo(i);	delete f;   }   bar* b	=	new bar("hello");   bar* b2	=	new bar("goobye");   delete b; delete b2;}

#ifndef __MEM_Pool_h__#define __MEM_Pool_h__/*  * Name: cPool class  * Author: "The Jeff"  * Date: 20/03/05 23:46  * Description: Allocates a pool of memory and interacts with said pool via a  * linked list. The memory is allocated when the cPool constructor is called   * and de-allocated when the destructor is called. A call to Alloc returns   * a pointer to the next available slot in memory and Free returns a block  * of memory back to the pool. Once all objects have been freed the pool is   * de-allocated. The cSafePool class provides a base class for objects that will  * become pool types. The safe pool is type-safe and ensures that the correct forms  * of operator new and delete are called.  *  * Declared within the namespace whileone  *  *  * Changes: None*/namespace whileOne {  typedef unsigned char uchar;class cPool {  public:    cPool(size_t size, int n)     {                  m_topNode = new sNode();                  // Attempt to allocate memory equal to sizeof(object type) * number of objects       // in pool. If allocation fails the standard new exception is thrown.      try       {        m_topNode->memory = static_cast<uchar*>(::operator new(size * n));      }      catch(std::bad_alloc &)      {        throw;       }            sNode *node = m_topNode;      for(int i = 1; i < n+1; i++)       {        sNode *next = new sNode();                // Once a pointer has been established to the first block of memory, the function        // will loop until n is reached. Pointers will be assigned to each block of memory        // at an offset to the original pointer. The offset is equal to (i * object size)        next->memory = m_topNode->memory + (i * size);        next->prev = node;        node->next = next;        node = node->next;      }            m_curNode = m_topNode;    }        ~cPool()     {            sNode *next = m_topNode;      sNode *dead;            while(next)      {        dead = next;        next = next->next;        ::operator delete(dead->memory);        delete dead;      }    }        // Returns NULL if no more memory is available    void *Alloc(size_t size) throw()    {            // No more memory available so attempt to allocate some more      if(m_curNode->next == NULL)      {                sNode *node = new sNode();                try         {          node->memory = static_cast<uchar*>(::operator new(size));        }        catch(std::bad_alloc &)        {          throw;        }                node->prev = m_curNode;        m_curNode->next = node;        m_curNode = m_curNode->next;                return static_cast<void*>(node->memory);      }            void *memory = static_cast<void*>(m_curNode->memory);            if(m_curNode->next != NULL)         m_curNode = m_curNode->next;            return memory;     }        inline void Free(void *ptr, size_t size)    {            m_curNode = m_curNode->prev;            // Once the last object has been freed the constructor is called      // (subject to change)      if(m_curNode == m_topNode)        delete this;    }    private:    typedef struct sNode {      sNode *next;      sNode *prev;      uchar *memory;            sNode() : next(NULL), prev(NULL), memory(NULL) { }      ~sNode() { }    }sNode;        sNode *m_topNode;    sNode *m_curNode;        cPool(const cPool &);    cPool &operator=(const cPool &);};/*  * This version of the Pool class is strongly typed so it can only be used on objects  * of derived classes. SafePool's operator new returns a pointer to already existing  * memory so its use does not contradict the memory pool design. Operator delete ensures  * that the pointer is merely returned to the pool and the memory remains un-deleted.*/template <class T, int U> class cSafePool {  public:    cSafePool() { }        virtual ~cSafePool() { }        static void *operator new(size_t size)      { return Pool().Alloc(size); }        static void operator delete(void *p, size_t size)      { Pool().Free(p, size); }    private:    cSafePool(const cSafePool &);    cSafePool &operator=(const cSafePool &);        // Singleton pattern accessor: returns a reference to a pool object. Note the     // relationship between SafePool and Pool: SafePool is-implemented-as a pool.    static cPool &Pool()    {      static cPool pool(sizeof(T), U);            return pool;    }};}#endif // __MEM_Pool_h__