Datenkopie vom einen Record in ein anderes

[p80286]

Hallo zusammen,
ich hätte da mal eine Frage zum Kopieren von Daten zwischen zwei Records.

Delphi-Quellcode:

type
  tMyRecord1 : packed record
                 datum : tdatetime;
                 wert  : integer;
                 feld  : string[255];
               end;

var
  record1 : tMyrecord1;
  record2 : tMyrecord1;

// So funktioniert es immer
record1.datum:=record2.datum; 
record1.wert:=record2.wert;
record1.feld:=record2.feld;
 
//so geht es auch
move(record2,record1,sizeof(tMyrecord));

aber was ist wenn ich

Delphi-Quellcode:

type
  tMyRecord1 : packed record
                 datum : tdatetime;
                 wert  : integer;
                 feld  : AnsiString;
               end;

oder

Delphi-Quellcode:

type
  tMyRecord1 : packed record
                 datum : tdatetime;
                 wert  : integer;
                 feld  : String;
               end;

verwende?
dann sollte doch mit einem

Delphi-Quellcode:

move(record2,record1,sizeof(tMyrecord));

nur die Stringadresse kopiert werden und Änderungen in

Delphi-Quellcode:

record2.feld

hätten gleichzeitig Änderungen in

Delphi-Quellcode:

record1.feld

zur Folge?
Oder liege ich da falsch?

Gruß
K-H

[Der schöne Günther]

Ich verstehe nicht- Warum sollte man das tun? Record-Zuweisungen sind doch immer eine vollständige Kopie:

Delphi-Quellcode:

program Project16;

{$APPTYPE CONSOLE}

{$R *.res}

uses System.SysUtils;

type
   TMyRecord1 = packed record
      datum : tdatetime;
      wert : integer;
      feld : AnsiString;
   end;

var
   firstRecord, secondRecord:   TMyRecord1;

begin
  try
   firstRecord.datum := Now();
   firstRecord.wert := 42;
   firstRecord.feld := 'Hallo Welt';

   secondRecord := firstRecord;

   firstRecord.datum := 0.0;
   firstRecord.wert := 99;
   firstRecord.feld := 'Derp';

   WriteLn( DateTimeToStr(secondRecord.datum) );
   WriteLn(secondRecord.wert);
   WriteLn(secondRecord.feld);

  except
   on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  readln;
end.

[bernau]

Zitat:

Zitat von Der schöne Günther (Beitrag 1286315)

Ich verstehe nicht- Warum sollte man das tun? Record-Zuweisungen sind doch immer eine vollständige Kopie:

Weil ein String erst mal ein Pointer auf einen Speicherbereich ist und du nur den Pointer kopierst. Damit zeigen die Strings von beiden Records auf den gleichen Speicherbereich. Änderst du den einen Record, dann wird der Zweite direkt mit geändert.

Bei records habe ich es mir angewöhnt immer eine Assign-Procedure einzubauen.

Ich scheue "move" wie der Teufel das Weihwasser.

Delphi-Quellcode:

type
    TMyRecord1 = packed record
       datum : tdatetime;
       wert : integer;
       feld : AnsiString;
       Procedure assign(aSource:TMyRecord1);
    end;

implementation

Procedure assign(aSource:TMyRecord1);
begin
  datum := aSource.adatum;
  wert := aSource.wert;
  feld := aSource.feld;
end;

[mkinzler]

Komischerweise passiert das bei dem Beispiel nicht ;)

[Der schöne Günther]

Eben. Da wir hier AnsiStrings haben geht es wohl um Windows. Strings sind Copy on Write. Wenn sich ein String ändert, ändert er nur den Pointer und lässt diesen nun auf einen neuen Speicherbereich zeigen.

[bernau]

Zitat:

Zitat von mkinzler (Beitrag 1286317)

Komischerweise passiert das bei dem Beispiel nicht ;)

:oops:

Dennoch versuche ich das Kopieren von Speicherbereichen zu vermeiden.:lol:

[p80286]

Zitat:

Zitat von Der schöne Günther (Beitrag 1286318)

Eben. Da wir hier AnsiStrings haben geht es wohl um Windows. Strings sind Copy on Write. Wenn sich ein String ändert, ändert er nur den Pointer und lässt diesen nun auf einen neuen Speicherbereich zeigen.

D.h. mit "meinen move" liege ich auf der sicheren Seite?
Nicht daß wir uns falsch verstehen, eigentlich bevorzuge ich Pointer (da weiß man was man hat) aber wenn nur Werte vorhanden sínd/übergeben werden ist eine narrensichere allgemeingültige Verfahrennsweise ganz angenehm.

Gruß
K-H

[Der schöne Günther]

Ich finde, bei reinen Pointern weiß man eigentlich nicht im geringsten mehr was man hat. :-D Wenn die Motivation ist, einen Record zu kopieren reicht

Delphi-Quellcode:

meineKopie := einAndererRecord;

Narrensicherer geht es doch nicht ;-)

Auch:
Ich habe in meinem Leben noch nie Move(..) benutzt- String ist doch schon ein "managed" Type: Er hat einen Referenzzähler. Allein den machst du dir mit einer reinen Byte-Kopie schon kaputt: Er ist um eins zu niedrig.

[Mavarik]

NEIN!

Der Move von Records mit dynamischen Elementen ist i.d.R. falsch, da wie due geschrieben hast nur die Pointer kopiert werden.

Ein

Delphi-Quellcode:

SecondRecord := FirstRecord;

Macht intern eigentlich ein

Delphi-Quellcode:

SecondRecord.Feld := FirstRecord.Feld; // Natürlich für alle Elemente

Bei einer Zuweisung eines Records auf einen anderen, will man doch den Inhalt kopieren und nicht die Referenz...

Daher ist ein Assign nicht nötig...

Mavarik

[himitsu]

Um es nochmal klar zu erwähnen:

Ich rate grundsätzlich von Move und Co. ab (außer wenn es wirklich nicht anders geht, aber wenn, dann muß man ganz genau aufpassen was man da für Mist verzapft)

Und für die Zuweisung zweier Records, von gleichem/kompatiblem Typ, ist das garnicht nötig, da die Zuweisung via

Delphi-Quellcode:

:=

alles Wichtige erledigt.
Vorallem bezüglich der Referenzzählung von LongStrings, dynamischen Arrays, Interfaces, Variants usw.

Ein ShortString (z.B.

Delphi-Quellcode:

string[255]

) ist wie ein Record, statisches Array oder einfach gesagt wie ein Integer anzusehn und bereitet die wenigsten Probleme, unter den Strings.

Zitat:

dann sollte doch mit einem move(record2,record1,sizeof(tMyrecord)); nur die Stringadresse kopiert werden und Änderungen in
record2.feld hätten gleichzeitig Änderungen in record1.feld zur Folge?
Oder liege ich da falsch?

Ja, aber vorallem schrottest du damit die automatische Speicherverwaltung (des

Delphi-Quellcode:

String

) und alles ist im Arsch.


Wer unbedingt einen "Move"-Befehl verwenden will, der hat dafür New/Initialize/InitializeRecord/InitializeArray, Dispose/Finalize/FinalizeRecord/FinalizeArray und Copy/CopyArray/CopyRecord aus der System-Unit verwenden.