🚀 go-pugleaf

Arnd Heimann  (sbah0508) wrote on 26.01.96
about "Reallocierung mit new ?":

> 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 ?

Unter ANSI gibt es zu new/delete kein passendes realloc, und trotzdem
realloc zu benutzen fuer einen mit new angeforderten Speicherbereich
funktioniert zwar bei manchen Implementierungen ist aber
ausgesprochener Schwachsinn.
Du must Dir also selber eine passende Funktion basteln.

---                                     Take a look at ...
Walter Sommergruber                                    The Software Site
email: wsog@softsite.co.at           http://www.softsite.co.at/softsite/

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 ?

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.

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

Gruss


        Uz




-- 
Ullrich von Bassewitz                              uz@ibb.schwaben.com

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

Dietmar Kuehl (kuehl@horn.informatik.uni-konstanz.de) wrote:
> Das Problem bei einer Verschiebeaktion sind eher die Referenzen, die
> noch auf das Objekt zeigen. Ansonsten, hier ist ein Template fuer sowas:

Das Problem mit den Referenzen hast Du auch mit realloc(), deshalb bin ich
mal davon ausgegangen, dass der restliche Code keine weiteren Referenzen auf
den Speicherbereich haelt.

>       T    *new_array = (T*)operator new(new_size * sizeof(T));

Ist das wirklich richtig? Ich sage da immer

        T *new_array = new T [new_size];

Vor allem die Multiplikation mit sizeof (T) kommt mir ziemlich spanisch
vor...

Gruss


        Uz

-- 
Ullrich von Bassewitz                              uz@ibb.schwaben.com