c++ Code nach Delphi portieren

[MasterTobi]

Guten Morgen,

also ich habe hier folgenden Code

Code:

 public Encrypt(string[])
  {
   for(new x=0; x < strlen(string); x++)
     {
        string[x] += (3^x) * (x % 15);
        if(string[x] > (0xff))
        {
           string[x] -= 256;
        }
     }
   return 1;
  }

vll erkennt einer oder der andere diesen code :)

wie kann ich diesen code nun in delphi umbauen :( habe schon einiges probiert

(3^x) * (x % 15) <<< hier sagt er mir dann immer fehler, wenn ich dies in delphi umschreibe

vll kann mir jemand helfen


mfg
Tobi

[edit=mkinzler]C-Tag eingefügt Mfg, mkinzler[/edit]
[edit=SirThornberry]Aussagekräftigeren Titel vergeben der das Problem ansatzweise beschreibt - Mfg, SirThornberry[/edit]

[DSFreak]

Delphi-Quellcode:

string[x] := string[x] + (Power(3,x) * (x mod 15));

Ist ungetestet.

[MasterTobi]

egnau das hat ich auch ma un da sagt er mir

[Fehler] Unit1.pas(34): E2008 Inkompatible Typen

:(

[igel457]

"^" ist nicht Power! "^" ist ein Bitweises XOR. Außerdem wird hier nichts an den String angefügt sondern (wenn ich das Richtig verstehe) etwas zu den Zeichen dazuaddiert.

Also eher:

Delphi-Quellcode:

string[x] := Chr(Ord(string[x]) + (3 xor X) * (X mod 15));

[Mithrandir]

Als was ist denn x deklariert?

[Jürgen Thomas]

Zitat:

Zitat von Daniel G

Als was ist denn x deklariert?

Offensichtlich als Laufvariable der for-Schleife. Jürgen

[Mithrandir]

Zitat:

Zitat von Jürgen Thomas

Offensichtlich als Laufvariable der for-Schleife. Jürgen

Moin,

das ist mir klar. ;) Ich wollte auch eher wissen, wie er in seinem Delphi-Code die Variable x deklariert hat. Denn irgendwie müssen die inkompatiblen Typen ja entstehen. ;)

[MasterTobi]

also schaut :

Delphi-Quellcode:

var x:Integer;
PW :string;
begin
PW:='king007';
for x:=1 to length(pw) do
PW[x] := Chr(Ord(PW[x]) + (3 xor X) * (X mod 15));
edit3.text:=PW;
end;

habe das nun so

edit :

die inko..... entstehen bei Power(3,x)


nochma edit: xD

also in dem c code im ersten post
ist der string dann verschlüselt so : kkpgLNU
in dem delphi code : mknƒNNS

[Mithrandir]

Jupp, ist mir jetzt auch wieder eingefallen, dass Power keinen Integer mag. ;) Aber der Code funktioniert jetzt, oder?

[MasterTobi]

ah sry schau nochma ein post über dir :)


aso hier das fehlt glaub ich auch noch :(

if(string[x] > (0xff))
{
string[x] -= 256;
}

[SirThornberry]

Der Code funktioniert in Delphi mit normalen AnsiStrings eventuell nicht.
Und das erkennt man eben daran:

Code:

if(string[x] > (0xff))

Denn ein einzelnes Zeichen kann in Delphi keinen Wert größer 255 haben. Allerdings kann es auch sein das ein normaler String doch geht, denn beim Überlauf passiert genau das gleiche. Denn wenn auf 255 beispielsweise 2 addiert werden kommt 257 raus was bei einem Überlauf eine 1 wäre.
Und das gibt eben das gleiche wie 257 - 256.

Wenn man das ganze also mit einem älteren Delphi macht sollte es ohne diese Prüfung funktionieren. Verwendet man jedoch eine Version wo ein Zeichen einen Wert größer 255 annehmen kann (unicode zum Beispiel) so muss eben die Korrektur manuell gemacht werden. Es wäre also interessant zu wissen welche Delphiversion verwendet wird (wurde im Profil ja leider nicht angegeben).

[Mithrandir]

Aber dann wäre interessant zu wissen, warum die Ausgaben aus C und Delphi so unterschiedlich sind. Zumal sich in Delphi ein Muster erkennen lässt, in C aber nicht...

[turboPASCAL]

Sodele...

Delphi-Quellcode:

function Encrypt(var txt: string): bool;
var x: byte;
begin
  for x := 1 to length(txt) do
  begin
    txt[x] := Chr( BYTE(Ord(txt[x]) + round(Power(3, x)) * (x mod 15)) );
    if Ord(txt[x]) >= 255 then
    begin
      txt[x] := Chr( Ord(txt[x]) - 255 );
    end;
  end;
  Result := True;
end;

[Mithrandir]

Zitat:

Zitat von turboPASCAL

Sodele...

Du bist süß:

Zitat:

Zitat von igel457

"^" ist nicht Power! "^" ist ein Bitweises XOR.

Und damit haben wir wieder den Delphi-Output, den Tobi in #8 angegeben hat. ;)

[SirThornberry]

Fast richtig. In C++ läuft die schleife von 0 bis Length - 1, in Delphi jedoch von 1 bis Length. Die schleifenvariable wird jedoch für die Verschlüsselung verwendet :tongue: In C++ werden also zur Verschlüsselung die Werte 0,...,length - 1 verwendet und bei den gezeigten Delphicodes 1,...,length was zu unterschiedlichen Werten führt.

[Mithrandir]

Jepp, so isses, und diese Funktion produziert denselben Output wie die Variante in C:

Delphi-Quellcode:

function Encrypt(var txt: string): bool;
var x: byte;
begin
  for x := 1 to length(txt) do
  begin
    txt[x] := Chr( BYTE(Ord(txt[x]) + (3 xor (X-1)) * ((X-1) mod 15)) );
    if Ord(txt[x]) >= 255 then
    begin
      txt[x] := Chr( Ord(txt[x]) - 255 );
    end;
  end;
  Result := True;
end;

[MasterTobi]

ihr assis xD

genau das letzte funktioniert :)

ich hätte nie gedacht das sich soviele darüber ein kopf machen

deswegen danke ich hier allen =) VIELEN DANK

[Mithrandir]

Zitat:

Zitat von MasterTobi

ich hätte nie gedacht das sich soviele darüber ein kopf machen

Ich auch nicht. :mrgreen:

[SirThornberry]

STOP - die Funktion oben ist Fehlerhaft :mrgreen:
genau gesagt ist folgendes fehlerhaft:

Delphi-Quellcode:

if Ord(txt[x]) >= 255 then 
begin 
  txt[x] := Chr( Ord(txt[x]) - 255 ); 
end;

richtig ist

Delphi-Quellcode:

if Ord(txt[x]) > 255 then 
begin 
  txt[x] := Chr( Ord(txt[x]) - 256 ); 
end;

Wobei der Compiler bei alten Delphiversionen da eben (wie bereits erwähnt) eine Warnung ausgeben wird weil der Wert niemals größer 255 sein kann bei AnsiStrings.
am besten also txt als AnsiString definieren und dann kann

Delphi-Quellcode:

if Ord(txt[x]) > 255 then 
begin 
  txt[x] := Chr( Ord(txt[x]) - 256 ); 
end;

weg gelassen werden.

[mkinzler]

Oder das als weiteres Modulo implemnetieren:

Delphi-Quellcode:

txt[x] := Chr( (BYTE(Ord(txt[x]) + (3 xor (X-1)) * ((X-1) mod 15)) ) mod 255);

[SirThornberry]

Naja, in deinem speziellen Fall macht es keinen Sinn. Denn es wird auf Byte gecastet und damit ist es gar nicht möglich das der Wert größer 255 ist :wink:
Ebenso fällt mir auf das somit

Delphi-Quellcode:

if Ord(txt[x]) > 255 then 
begin 
  txt[x] := Chr( Ord(txt[x]) - 256 ); 
end;

auch bei neuen Delphiversionen nicht nötig ist da eben durch den Cast auf Byte sichergestellt wird das ein Überlauf statt findet und somit niemals ein Wert größer 255 entsteht.

[Edit]@mkinzler: und müsste es nicht wenn dann "mod 256" heißen?[/Edit]

[Muetze1]

Zitat:

Zitat von SirThornberry

Delphi-Quellcode:

if Ord(txt[x]) > 255 then 
begin 
  txt[x] := Chr( Ord(txt[x]) - 256 ); 
end;

auch bei neuen Delphiversionen nicht nötig ist da eben durch den Cast auf Byte sichergestellt wird das ein Überlauf statt findet und somit niemals ein Wert größer 255 entsteht.

In diesen Codeabschnitt ist kein Cast und somit kann bei D2009 Ord() einen Wert > 255 liefern.

Zitat:

Zitat von SirThornberry

[Edit]@mkinzler: und müsste es nicht wenn dann "mod 256" heißen?[/Edit]

Ja sollte es.