Hallo,


gibt es eine elegante Moeglichkeit folgendes in Delphi zu schreiben?

markieren

Code:

int8  tmp1;
int  tmp2;
int64 tmp3;

Source >> tmp1 >> tmp2 >> tmp3;

In Delphi wuerde ich es so uebersetzen:

markieren

Delphi-Quellcode:

tmp1 := pInt8(Source)^;
tmp2 := pInt(Source + SizeOf(int8))^;
tmp3 := pInt64(Source + SizeOf(int8) + SizeOf(int))^;

Ich persönlich finde das recht unschoen, folgendes gefaellt mir da schon besser:

zusammenfalten · markieren

Delphi-Quellcode:

type
 TSource = record
  tmp1: Int8;
  tmp2: Int;
  tmp3: Int64;
 end;
 PSource = ^TSource;

[...]

tmp1 := PSource(Source)^.tmp1;
tmp2 := PSource(Source)^.tmp2;
tmp3 := PSource(Source)^.tmp3;

Ist aber doch relativ unflexibel, gibt es noch eine andere Moeglichkeit?


Gruß,

Win32.API

Source ist aller Wahrscheinlichkeit nach ein Stream? Dann kannst du in einem neueren Delphi einen Operator (zb shr, was >> ja sein soll) überladen. Ansonsten könntest du dir eine Klasse basteln, die einen Stream annimmt und über Methoden ReadInt, ReadLong, ... elegaten Zugriff ermöglicht.

Hallo Dax,

vielen dank fuer deine Antwort. Ich verwende Delphi 2007, ueberladen von Operatorn ist also moeglich. Wie sehen denn der Zugriff aus?

markieren

Delphi-Quellcode:

Source >> tmp1 >> tmp2 >> tmp3; //Wird nicht gehen, oder liege ich falsch?

//Eher so, oder?
Source >> tmp1;
Source >> tmp2;
Source >> tmp3;

Ich weiss nicht, ob Delphi Referenzen in Operatoren zulässt, aber wenn es das tut, dann wäre esSource shr tmp shr tmp2 shr tmp3 Wie man sieht, verliert das ganze Konstrukt durch den Wegfall der Pfeilmetapher nicht nur seinen optischen Reiz, für Neulinge ist es auch völlig unverständlich (und für dich nach ner Weile sicherlich auch)...

Zitat von Win32.API:

Hallo,


gibt es eine elegante Moeglichkeit folgendes in Delphi zu schreiben?

markieren

Code:

int8  tmp1;
int  tmp2;
int64 tmp3;

Source >> tmp1 >> tmp2 >> tmp3;

In Delphi wuerde ich es so uebersetzen:

markieren

Delphi-Quellcode:

tmp1 := pInt8(Source)^;
tmp2 := pInt(Source + SizeOf(int8))^;
tmp3 := pInt64(Source + SizeOf(int8) + SizeOf(int))^;

Das glaube ich eigentlich nicht. ">>" ist ein Operator von istream o.ä. und das geht halt so in Delphi nicht.
Object Pascal fehlen halt noch viele Meilen zu C++ (Auch wenn ich mir damit hier keine Freunde mache)

Hier wäre die äquivalente Lösung in Delphi.
C/C++ kann hier zwei Vorteile ausspielen:
1.) seinen Increment/Decrement - Operator
man kann also schreiben a = *p++; wobei der Inhalt des Pointer p ausgelesen wird und anschliesend der Zeiger erhöht wird.
In Delphi braucht man dazu zwei Befehle.
2.) das Überladen von Operatoren
C++ hat viele Operatoren, die sich überladen lassen und wählt automatisch die passende Funktion.
Delphi fehlen die Operatoren ++,--, >>, << weshalb das Überladen der Operatoren deutlich weniger nützt.

Allerdings hat das Überladen von Operatoren auch den Nachteil, dass der Sourcecode für Aussenstehende schwerer zu verstehen ist.
Man kann mit diesem Feature auch viel Unheil anrichten.

zusammenfalten · markieren

Delphi-Quellcode:

function GetInt8(var x:Pointer):Byte;
begin
  Result := PByte(x);
  x := PByte(x) + 1;
end;
function GetInt(var x:Pointer):Integer;
begin
  Result := PInteger(x);
  x := PInteger(x) + 1;
end;
...
tmp1 := GetInt8(source);
tmp2 := GetInt(Source);

Hallo,

einige kleine Korrekturen:

zusammenfalten · markieren

Delphi-Quellcode:

function GetInt8(var x:Pointer):Byte;
begin
  Result := PByte(x)^;
  Inc (PByte(x));
end;

function GetInt(var x:Pointer):Integer;
begin
  Result := PInteger(x)^;
  Inc (PInteger(x));
end;

Ab Delphi 2006 könnte man das Problem natürlich auch durch Records mit Methoden erschlagen:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMemoryReader = record
  private
    p : Pointer;
  public
    procedure Init (const aValue : Pointer); inline;
    function ByteValue : Byte; inline;
    function IntegerValue : Integer; inline;
  end;

procedure TMemoryReader.Init (const aValue : Pointer);
begin
  p := aValue;
end;

function TMemoryReader.ByteValue : Byte;
begin
  Result := PByte(p)^;
  Inc (PByte(p));
end;

function TMemoryReader.IntegerValue : Integer;
begin
  Result := PInteger(p)^;
  Inc (PInteger(p));
end;

// Anwendung

var
  Reader : TMemoryReader;
begin
  Reader.Init (Source);
  tmp1 := Reader.ByteValue;
  tmp2 := Reader.IntegerValue;
end;

Man sollte aber bei all diesen Versuchen das beherzigen, was sx2008 gesagt hat: je kompakter der Code wird, desto schwerer ist er für Dritte (und manchmal auch für den Programmierer) zu verstehen. Wer die Syntax von C++ haben möchte, der sollte besser in C++ programmieren...

Gruß Hawkeye

Zitat von Hawkeye219:

Wer die Syntax von C++ haben möchte, der sollte besser in C++ programmieren...

100% Zustimmung. C++ ist nun mal nicht Object Pascal und wenn man dann noch die STL verwendet, ist das Programmieren und auch die Denkweise was komplett anderes als Object Pascal.

Zitat:

2.) das Überladen von Operatoren
C++ hat viele Operatoren, die sich überladen lassen und wählt automatisch die passende Funktion.
Delphi fehlen die Operatoren ++,--, >>, << weshalb das Überladen der Operatoren deutlich weniger nützt.

Der >> und << Operator ist doch vorhanden (ist nichts anderes als shl und shr (wie bereits jemand anderes weiter oben beschrieben hat)).

Passiert bei

markieren

Delphi-Quellcode:

tmp1 := pInt8(Source)^;
tmp2 := pInt(Source + SizeOf(int8))^;
tmp3 := pInt64(Source + SizeOf(int8) + SizeOf(int))^;

wirklich das gleiche wie beim Original C++ Quellcode?

Zitat von SirThornberry:

Der >> und << Operator ist doch vorhanden (ist nichts anderes als shl und shr (wie bereits jemand anderes weiter oben beschrieben hat)).

Äääähm. Das ist so nicht ganz richtig

markieren

Delphi-Quellcode:

int iWert = 21;
cout << "Die halbe Antwort = " << iWert << endl;

//oder

int iNocheinWert
cin >> iNocheinWert;

Schreibt bzw. liest was in bzw. aus dem Standard-Ausagbe- oder EingabeStream. Schon was anderes als Left- oder Rightshift. Obwohl das mit << und >> auch geht. Darum auch nur "nicht ganz richtig"