🚀 go-pugleaf

Hi,
Ullrich von Bassewitz (uz@wuschel.ibb.schwaben.com) wrote:
: Arnd Heimann (sbah0508) wrote:
: > Aber kann mir jemand sagen, ob es auch moeglich ist,
: > aehnlich wie mit 'realloc()' solche mit new allocierten Speicherbereiche
: > zu reallocieren,
: > also neuen ausreichend grossen Platz anzufordern, die Inhalte zu 
: > verschieben und den alten Platz wieder freizugeben ?

Ich wuerde hoch wetten, dass Du irgendwann mal C gelernt hast! Jemand,
der nie C gelernt hat braucht sowas naemlich nicht :-) C++ bietet weit
bessere Moeglichkeiten die Sachen zu machen und benoetigt einen
derartigen low-level Programmierstil nicht (man braucht sowas
vielleicht, wenn man eine Array-Klasse implementiert, aber ich gehe
davon aus, dass dies nicht gerade gemacht wird, da man dafuer die
Sprache besser kennt...).

: Der operator new() kann das nicht(*), eine solche Funktion selber zu
: schreiben (evtl. unter Verwendung eines Templates) ist aber wohl kein
: Problem. Das einzig schwierige dabei ist, dass normalerweise (d.h. ohne
: Nachhilfe Deinerseits) keine Informationen darueber vorliegen, wie gross
: der alte Block war. Wenn Du's Dir einfach machen willst, dann kannst Du
: den alten Block immer freigeben und neu allozieren.

Das Problem bei einer Verschiebeaktion sind eher die Referenzen, die
noch auf das Objekt zeigen. Ansonsten, hier ist ein Template fuer sowas:

  #include <new>

  template <class T> T *objrealloc(T *old_array, int old_size, int new_size)
  {
    if (old_size == new_size)
      return old_array;
    if (old_size < new_size)
    {
      void *old = (void*)old_array; 
      T    *new_array = (T*)operator new(new_size * sizeof(T));
      int  i = 0;
      
      while (i < old_size)
      {
	new(new_array + i) T(old_array[i]);
	++i;
      }
      while (i < new_size)
      {
	new(new_array + i) T();
	++i;
      }

      operator delete(old);
      return new_array;
    }
    else
    {
      for (int i = old_size; i < new_size; ++i)
	old_array[i].~T();
      return old_array;
    }
  }

Ich habe den Code nicht getestet, denke aber dass er im Wesentlichen
(ausser ein paar Typos) korrekt ist (naja, expection handling
fehlt...). Benutzen wuerde ich sowas allerdings nicht! Eine aehnliche
Diskussion in comp.lang.c++ (im September glaube ich) hat mich dazu
verleitet, eine Arrayklasse zu schreiben, die unter anderem einen
'realloc()' machen kann. Als Beispiel kann man sich das mal angucken:

  http://www.informatik.uni-konstanz.de/~kuehl/c++/array.h.html

Benutzen sollte man aber besser 'vector': Wie gesagt, Arrayklassen
laesst man besser von Experten schreiben.

: (*) Laesst sich hier vielleicht ueber einen zusaetzlichen Parameter zu new()
: etwas machen?

Nein, keine Chance (zumindest nicht portable). Ist eigentlich auch
nicht noetig.  Wie gesagt: man verwendet besser eine Arrayklasse
anstatt es von Hand zu machen.
--
dietmar.kuehl@uni-konstanz.de
http://www.informatik.uni-konstanz.de/~kuehl
I am a realistic optimist - that's why I appear to be slightly pessimistic