Klassespecifik operator new og delete

Jeg er ved at lave en klassispecifik implementering af operator new og delete. Det ser indtil videre således ud:

template<int dim,typename T>
void * Vector<dim,T>::operator new(size_t n)
{
    const int N = 20 ;        // antal enheder, der skal besilles plads til ad gangen.
    heapBlok * p;
    Vector<dim,T> *q;

    // Hvis lokal heap er tom, allokeres plads til N objekter fra den globale heap
    if ( heapPtr == 0 )
    {
        q = ::new Vector<dim,T>[N];    // global new
        heapTotal += N;
       
        // lav de nye N objekter om til en lineær liste af heapBlok'ke.
        for ( int i = 0 ; i < N-1 ; i++ )
        {
            p = (heapBlok*)&q[i];
            p->next = (heapBlok*)&q[i+1];
        }
        p = (heapBlok*)&q[N-1];
        p->next = 0;
        heapPtr = (heapBlok*)q;        // heap pointer peger på første element i liste.
    }

    heapUsed++;                        // vi "frigiver" en blok, opdater tæller
    // Hægt første blok af listen og returner dens adresse.
    q = (Vector<dim,T> *)heapPtr;
    heapPtr = heapPtr->next ;
    return q;
}

template<int dim,typename T>
void Vector<dim,T>::operator delete(void *p)
{
    heapBlok *q = (heapBlok*)p;

    // blokken, der er returneret, indsættes forrest i listen.
    q->next = heapPtr;
    heapPtr = q;

    // opdater tæller.
    heapUsed--;
}

Mit problem er nu, hvordan får jeg på en effektiv og sikker måde leveret deallokeret plads tilbage til den globale heap, når jeg ikke skal bruge pladsen længere ?