Selbstdefinierte new/delete-Operatoren

     

Für kleine, häufig allokierte Objekte kann new zu teuer sein:

    class ding
    { beschr *bs;
      public:
      ...
    };
    ding *d = new ding;

liefert:

Idee: Speicherverwaltung selbst schreiben:

    class ding
    { beschr *bs;
      static ding* freiliste;
      public:
      void* operator new(size_t size);
      void operator delete(void * weg, size_t size);
    }
    ding* ding::freiliste = 0;

Dieses new allokiert Speicherplatz fuer mehrere Objekte des Typs ding und benutzt den Zeiger bs, um diese zu verketten:

    void* ding::operator new(size_t size)
    { if (size != sizeof(ding))
         return ::new char[size];
      ding *p = freiliste;
      if (p)       
      { freiliste = (ding*) p->bs;
        return p;
      }
      // neuer "roher" Speicher:
      ding *neu = (ding*) 
                   new char[256*sizeof(ding)];
      for (int i = 0 ; i < 255; i++)
          neu[i].bs = (beschr*)&neu[i+1];
      // Ende der Freiliste:
      neu[255].bs = 0;
      freiliste = &neu[1];
      return neu;
    }

Natürlich braucht dieses new ein eigenes delete!

    void ding::operator delete(void *weg,
                                size_t size)
    { // sende falsche Objekte 
      // zum globalen delete:
      if (size != sizeof(ding))
      { ::delete[]((char*)weg);
        return;
      }
      ding *frei = (ding*) weg;
      frei->bs = (beschr*) freiliste;
      freiliste = frei;
    }