newbie: ar[1] at end of POD

Hi,

I am creating pools of small integer arrays. There are individual
allocs from the pool, but
no frees to the pool, and one free for the whole pool. The pool
creates chunks of 10000 elem
arrays. I subdivide the chunk into Snippet as follows:

class Snippet {
     friend class SnippetPool;

     int ar[1]; // first element is length
                           // enough room in Snippet object to hold more
elems
                           // this is the ONLY data member of POD

     public:

     int length () const
     {
         return ar[0];
     }

     int& operator [] (int i)
     {
         return ar[i+1]; // bounds check omitted
     }
};

My question is if I have a large chunk of int*, how do I create
Snippets of length N
from these chunks? Want it to work on all platforms! For example,

class SnippetPool {
     // assume that we have one chunk big enough to
     // hold all snippets, and destructor throws away chunk

     int* buffptr;
     int buffcnt;

     Snippet* Alloc (int len)
     {
          len++;
          if (len < 1 || len > buffcnt)
              throw MyException();

          void* p = buffptr;
          buffptr += len;

          // does the following make assumptions about the C++
          // implementation of POD? What's better?
          Snippet* s = static_cast<Snippet*>(p);

          // set the logical length for caller
          // but leave rest of array as garbage
          s->ar[0] = len-1;
          return s;
     }
};

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]