understanding strict aliasing

Hello,
consider the following piece of code, which is a variant of the Pool
allocator from Stroustroup's book (chapter 19 IIRC)
[disclaimer, I'm recalling the code from memory, I don't have the book in
front of me right now]:

struct Pool {
    struct Link { Link *next; };
    struct Chunk {
        Chunk *next;
        char mem[4 * sizeof(Link)];
    };

    Link *head;
    Chunk *chunks;

    Pool()
    {
         chunks = new Chunk();
         char *start = chunks->mem;
         // ...
         head = reinterpret_cast<Link *>(start);
    }

    void *alloc()
    {
         Link *p = head;
         head = head->next;
         return p;
    }

    void free(void *p)
    {
        Link *l = static_cast<Link *>(p);
        l->next = head;
        head = l;
    }
};

My question is: doesn't the above code break the strict aliasing
requirements (3.10/15 of the C++03 standard)? My understanding is that it
does, since both in alloc() and in free() we are accessing chunks->mem[0]
from a Link *, or am I wrong? If I'm wrong, can somebody clarify this? If
I'm right, is there a portable, standards-compliant way of achieving the
same (i.e. implementing a pooled allocator along the above lines)?

Thanks in advance,
Alberto

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