class operator OnesComplement ? o.O

[marky522]

Hallo Himitsu,

bitweises invertieren läßt sich auch durch folgende Operation durchführen:

bei Bytes:
x := x xor $FF
bei Word:
x := x xor $FFFF
bei Integer:
x := x xor $FFFFFFFF
usw.

mfg

Markus

[himitsu]

Ich wollte es nicht nutzen ... war nur neugierig, da es das ja scheinbar gibt, aber es noch keiner kenn


bei Bytes:
x := not x oder x := x xor not 0
bei Word:
x := not x oder x := x xor not 0
bei Integer:
x := not x oder x := x xor not 0
usw.

oder eben LogicalNot nutzen und darin einfach bitweise Invertieren

[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.