class operator OnesComplement ? o.O

[himitsu]

Da ich grade wieder drüber gestopert bin und meinen alten Post in Google fand... (falls es auch Andere finden)

OnesComplement ist in Delphi nicht nutzbar (auch wenn man es dort implementieren kann).
Es ist eigentlich für den C++Builder gedacht und .NET kennt den Befehl ebenfalls. LogicalNot ist also das "logische not" (Boolean) und OnesComplement das "binäre not" (Integer).

Außerdem gibt es auch noch die undokumentierten True und False.
Für if MyRecord then implementiert man somit das MyRecord.True , wobei man natürlich auch einen Implicit-Cast nach Boolean verwenden könnte.

Schachsinnig ist, daß der Delphicompiler bei if not MyRecord then nicht das MyRecord.False oder not MyRecord.True benutzt, sondern es zwanghaft nach MyRecord.LogicalNot.True übersetzen will, was beim Fehlen des LogicalNot schön knallt.

Delphi-Quellcode:

TRecord = record
  class operator OnesComplement(A: TRecord): TRecord;
  class operator True(A: TRecord): boolean;
  class operator False(A: TRecord): boolean;
end;

[Stevie]

Zitat von himitsu:

Außerdem gibt es auch noch die undokumentierten True und False.

Cool, die kannt ich gar nicht - und hätt sie neulich sogar gebrauchen können

[himitsu]

IstWar halt geheim.

Hier nochmal alles, was die Kompiler (bis XE7) kennen:
http://geheimniswelten.de/sonstiges/...senoperatoren/
(fehlt nur noch Initialize, Finalize und CopyRecord )

[Der schöne Günther]

Oder man erlaubt endlich einen impliziten Standard-Konstruktoraufruf (und Destruktor) für Records. Warum das nicht implementiert ist habe ich nie verstanden.

[himitsu]

OK, ob es Initialize und Finalize heißt (siehe die Funktionen in der System.pas) oder Contrucor (ohne Parameter) und Destructor, ist ja erstmal egal. (aber stimmt, deinee Namen klingen besser)
Es werden für Records bereits diese Methoden ausgeführt (siehe System.pas), aber es gibt keine Weiterleitung zu "eigenen" Implementationen, was sich durch die zentralen Stellen hätte bestimmt ganz leicht implementieren lassen.

[Mavarik]

Zitat von himitsu:

CopyRecord )

Jo das Fehlt!

und was ist Convert?

[himitsu]

Zitat von Mavarik:

und was ist Convert?

Meinst du die "Konvention"?

Delphi-Quellcode:

var
  A, B: TMyRecord;
begin  // Initialize/Create
  ...
  A := B;  // Copy (B -> A) + Finalize (altes A)
  ...
end;  // Finalize/Destroy

Beim Copy werden "direkte" Inhalte kopiert (Move) und Referenzen von Interface, String, dyn. Array, Variant und ARC-Objecten behandelt,
aber eigene Behandlungen kann man nicht durchühren, wie z.B. das darin verlinkte Interface/Objekt zu klonen, was man oft benötigen könnte.

[Stevie]

Nur mal kurz zusammengeschludert:

Delphi-Quellcode:

program RecordFinalizer;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  Generics.Collections,
  SysUtils,
  TypInfo,
  DDetours;

type
  TFinalizer = procedure (Self: Pointer);
  TCopyOperator = procedure (Dest, Source: Pointer);

var
  Finalizers: TDictionary<PTypeInfo,TFinalizer>;
  CopyOperators: TDictionary<PTypeInfo,TCopyOperator>;

type
  TMyRecord = record
  private
    s: string;
  public
    procedure Destroy;
    class procedure Copy(var dest, source: TMyRecord); static;
  end;

{ TMyRecord }

class procedure TMyRecord.Copy(var dest, source: TMyRecord);
begin
  dest.s := 'Copy: ' + source.s;
end;

procedure TMyRecord.Destroy;
begin
  Writeln(s);
  Writeln('TMyRecord.Destroy');
end;

procedure Main;
var
  r, r2: TMyRecord;
begin
  r.s := 'Hello World';
  r2 := r;
end;


function GetFinalizeRecord: Pointer;
asm
  mov @Result, offset System.@FinalizeRecord
end;

function GetCopyRecord: Pointer;
asm
  mov @Result, offset System.@CopyRecord
end;

var
  FinalizeRecord: function(p: Pointer; typeInfo: Pointer): Pointer;
  CopyRecord: procedure (Dest, Source, TypeInfo: Pointer);

function FinalizeRecordHook(p: Pointer; typeInfo: Pointer): Pointer;
var
  finalizer: TFinalizer;
begin
  if Finalizers.TryGetValue(typeInfo, finalizer) then
    finalizer(p);
  if Assigned(FinalizeRecord) then
    Result := FinalizeRecord(p, typeInfo);
end;

procedure CopyRecordHook(Dest, Source, TypeInfo: Pointer);
var
  copyOperator: TCopyOperator;
begin
  if CopyOperators.TryGetValue(TypeInfo, copyOperator) then
    copyOperator(Dest, Source)
  else
    CopyRecord(Dest, Source, TypeInfo);
end;

begin
  Finalizers := TDictionary<PTypeInfo,TFinalizer>.Create;
  Finalizers.Add(TypeInfo(TMyRecord), @TMyRecord.Destroy);

  CopyOperators := TDictionary<PTypeInfo,TCopyOperator>.Create;
  CopyOperators.Add(TypeInfo(TMyRecord), @TMyRecord.Copy);

  FinalizeRecord := InterceptCreate(GetFinalizeRecord, @FinalizeRecordHook);
  CopyRecord := InterceptCreate(GetCopyRecord, @CopyRecordHook);

  try
    Main;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;
  ReportMemoryLeaksOnShutdown := True;

  InterceptRemove(@FinalizeRecord);
  InterceptRemove(@CopyRecord);
  Finalizers.Free;
  CopyOperators.Free;
end.

[Mavarik]

Zitat von Stevie:

Nur mal kurz zusammengeschludert:

Hi Stevie!

Immer wenn ich "Deinen" Sourcecode lese, habe ich das Gefühl ich habe keine Ahnung von Delphi...

Bedeutet das ich kann doch den RecordCopy "überladen"?

Problem ist:

Delphi-Quellcode:

type
  TFoo = record
           A : Array of String;
         end;

Var
  Foo : TFoo;

Procedure MachNixMitFoo;
var
  Merk : TFoo;
begin
  Merk := Foo;
  Foo[3] := 'Soll nicht geändert werden';
  Machwas(Foo);
  Foo := Merk;
end;

Leider ist Foo[3] danach mit 'Soll nicht geändert werden' belegt, da "nur" die Referenzen Kopiert werden.

Bietet "Deine" Routine da einen Lösung?

Mavarik

[himitsu]

Das ist das eines der Probleme, die ich damit lösen wollte.

Für dynamische Arrays gibt es kein CopyOnWrite, wenn man schreibend auf ein Feld des dynamischen Arrays zugreift.
Bei Strings (die intern auch nur aufgemotzte dynamische Arrays sind) wird vor jedem Schreibzugriff auf ein Char (da ja array[1..length] of char ) sichergestellt, daß RefCount auch 1 ist.
(durch Aufruf von UniqueString)