Verschlüsselung bzw. Entschlüsselung will nicht gelingen

[Faffy]

Hey folks,

folgendes Problem beschäftigt mich nun bereits seit einigen Tagen.
Ich habe versucht ein Programm zu schreiben, welches individuell gewählte Worte verschlüsselt, indem man jeden Buchstaben des zu verschlüsselnden Wortes und einen gewissen Wert verschiebt. Die Verschlüsselung an sich funktioniert auch reibungsfrei, jedoch die Entschlüsselung soll das Wort wiederherstellen. Wenn ich den Button für die Entschlüsselung jedoch betätige, so bleibt das Feld leer. Ich habe einmal vor dem Betätigen des Buttons etwas in das Edit-Feld hinein geschrieben, in das der entschlüsselte Text eingefügt werden soll. Lustiger Weise wird alles, was sich in dem Feld befindet einfach gelöscht.

Hier einmal die Procedure des Buttons:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
 var T, TN              : String;
     Z                  : Integer;
begin
   T := Edit2.Text;                                                             // T = Verschlüsselter Text, der entschlüsselt werden soll
   Z := 7;                                                                      // Z = Wert, um den der Buchstabe verschoben wird
   C.B(TN,T,Z);                                                                 // C = Klasse TCaesar (Global deklariert), B = Methode zur Entschlüsselung
   Edit3.Text := TN;                                                            // TN = Neuer, entschlüsselter Text
end;

Und hier die Procedure der Entschlüsselungsmethode:

Delphi-Quellcode:

Procedure TCaesar.B (Var T : String; T2 : String; Z : Integer);
Var
 P, Code : Integer;                                                             // P = Länge des Wortes, Code = Verschlüsselungscode
 B       : String;                                                              // B = Buchstabe des Wortes
 B2      : Char;                                                                // B2 = Verschobener Buchstabe
Begin
For P := 1 to Length(T) Do
                                Begin
                                  B := Copy(T,P,1);
                                    Code := ORD(B[1]);
                                    Code := Code + Z;
                                    If (Code < 122) Then
                                                     Code := Code + 26;
                                    B2 := Char(Code);
                                    T2 := T2 + B2;
                                End;
                                End;

Ich hoffe ihr werdet mir helfen können.
Gruß
Faffy

[Insider2004]

Wieso machst Du Dir Dein Leben so schwer? Schau mal auf Deinen Code. Deiner grünen Kommentare sind länger als der Programmcode. Guter Code braucht keine Kommentare. Benenne Deine Variablen erst mal gescheit.

[Uwe Raabe]

Innerhalb deine Entschlüsselungsmethode hast du die Bedeutung von T und T2 vertauscht.

[Faffy]

Ah, mir ist aufgefallen, was mein Fehler war.. Ich habe den Quelltext jetzt ein wenig überarbeitet, sodass folgendes entstanden ist:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
 var T, TN              : String;
     Z                  : Integer;
begin
   T := Edit2.Text;                                                             // T = Verschlüsselter Text, der entschlüsselt werden soll
   Z := 7;                                                                      // Z = Wert, um den der Buchstabe verschoben wird
   C.B(TN,T,Z);                                                               // C = Klasse TCaesar (Global deklariert)
   Edit3.Text := TN;                                                            // TN = Neuer, entschlüsselter Text
end;

Und für die Methode:

Delphi-Quellcode:

Procedure TCaesar.B (Var T2 : String; T : String; Z : Integer);
Var
 P, Code : Integer;                                                             // P = Länge des Wortes, Code = Verschlüsselungscode
 B       : String;                                                              // B = Buchstabe des Wortes
 B2      : Char;                                                                // B2 = Verschobener Buchstabe
Begin
For P := 1 to Length(T) Do
                                Begin
                                  B := Copy(T,P,1);
                                    Code := ORD(B[1]);
                                    Code := Code + Z;
                                    If (Code < 122) Then
                                                     Code := Code - 26;
                                    B2 := Char(Code);
                                    T2 := T2 + B2;
                                End;
                                End;

Nun entschlüsselt er auch, jedoch wird nicht das entschlüsselt, was entschlüsselt werden soll. Er gibt nicht den Ausgangsbegriff wieder raus, sondern etwas völlig anderes. Aus "ttt" wird "MMM".

[Uwe Raabe]

Dann zeig doch mal die Verschlüsselung...

[Faffy]

Ich lege einfach mal alles genauer dar.

Verschlüsselungsbutton:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
Var T,T2 : String;
    Z  : Integer;

begin
  T := Edit1.Text;
  Z:= 7;
  C.A(T,T2,Z);
  Edit2.Text := T2;
end;

Verschlüsselungsmethode:

Delphi-Quellcode:

Procedure TCaesar.A (T : String; Var T2 : String; Z : Integer);                 // T = Zu verschlüsselndes Wort, T2 = Verschlüsseltes Wort, Z = Irrelevant (Zahl, um die verschoben wird, ist aber nicht angegeben)
Var
 P, Code : Integer;                                                             // P = Länge des Wortes, Code = Verschlüsselungscode
 B       : String;                                                              // B = Buchstabe des Wortes
 B2      : Char;                                                                // B2 = Verschobener Buchstabe
Begin
For P := 1 to Length(T) Do
                                Begin
                                  B := Copy(T,P,1);
                                    Code := ORD(B[1]);
                                    Code := Code - Z;
                                    If (Code > 122) Then
                                                     Code := Code - 26;
                                    B2 := Char(Code);                           // B2 = Verschlüsselter Buchstabe
                                    T2 := T2 + B2;                              // T2 = Verschlüsselter Text
                                End;
                                End;

Entschlüsselungsbutton:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
 var T, TN              : String;
     Z                  : Integer;
begin
   T := Edit2.Text;                                                             // T = Verschlüsselter Text, der entschlüsselt werden soll
   Z := 7;                                                                      // Z = Wert, um den der Buchstabe verschoben wird
   C.B(TN,T,Z);                                                               // C = Klasse TCaesar (Global deklariert)
   Edit3.Text := TN;                                                            // TN = Neuer, entschlüsselter Text
end;

Entschlüsselungsmethode:

Delphi-Quellcode:

Procedure TCaesar.B (Var T2 : String; T : String; Z : Integer);
Var
 P, Code : Integer;                                                             // P = Länge des Wortes, Code = Verschlüsselungscode
 B       : String;                                                              // B = Buchstabe des Wortes
 B2      : Char;                                                                // B2 = Verschobener Buchstabe
Begin
For P := 1 to Length(T) Do
                                Begin
                                  B := Copy(T,P,1);
                                    Code := ORD(B[1]);
                                    Code := Code + Z;
                                    If (Code < 122) Then
                                                     Code := Code + 26;
                                    B2 := Char(Code);
                                    T2 := T2 + B2;
                                End;
                                End;

[Uwe Raabe]

Das sind doch die relevanten Stellen:

Delphi-Quellcode:

  Code := Code - Z;
  If (Code > 122) Then
    Code := Code - 26;

Delphi-Quellcode:

  Code := Code + Z;
  If (Code < 122) Then
    Code := Code + 26;

Überleg dir mal, warum bei der Verschlüsselung die IF-Abfrage kommt und was sie bewirkt. Dann überleg mal, wie dieser Vorgang rückgängig gemacht werden muss. Dann siehst du auch, was bei der Enschlüsselung falsch läuft.

[DayDreamer87]

Zitat:

Zitat von Uwe Raabe (Beitrag 1245343)

Das sind doch die relevanten Stellen:

Delphi-Quellcode:

  Code := Code - Z;
  If (Code > 122) Then
    Code := Code - 26;

Delphi-Quellcode:

  Code := Code + Z;
  If (Code < 122) Then
    Code := Code + 26;

Überleg dir mal, warum bei der Verschlüsselung die IF-Abfrage kommt und was sie bewirkt. Dann überleg mal, wie dieser Vorgang rückgängig gemacht werden muss. Dann siehst du auch, was bei der Enschlüsselung falsch läuft.

Ich bin in der Materie zwar noch relativ neu und, sofern falsch, beachtet mich gar nicht...

Aber nachdem ich das ganze mal nachgebastelt habe, funktionierts nu bei mir :)
Fehler dürfte das im Zitat rot markierte Zeichen sein.

Hoffe mal, dass mein erster Beitrag korrekt ist.

Grüße

Day

Edit: Farbige Markierungen im Delphi Code funktionieren nicht...
In Prozedur B:
If (Code > 122) Then ... so funktionierts

[Faffy]

Perfekt, vielen Dank. Jetzt funktioniert es echt wunderbar, ihr habt mir sehr geholfen.

Eine Frage hätte ich jedoch noch, da mir das nicht ganz klar ist.
Warum muss bei Procedure A

Delphi-Quellcode:

Procedure TCaesar.A (T : String; Var T2 : String; Z : Integer);

Das "Var T2 : String" hinter "T : String;" stehen und bei Procedure B

Delphi-Quellcode:

Procedure TCaesar.B (Var T2 : String; T : String; Z : Integer);

das "Var T2 : String;" eben am Anfang?

[sx2008]

Zitat:

Zitat von Insider2004 (Beitrag 1245333)

Schau mal auf Deinen Code. Deiner grünen Kommentare sind länger als der Programmcode. Guter Code braucht keine Kommentare. Benenne Deine Variablen erst mal gescheit.

Das kann ich nur unterstützen!!
Variablen- und Funktionsnamen dürfen wirklich mehr als ein oder zwei Buchstaben lang sein.
Die Zeiten von Sharp Taschenrechner mit ihrem Basic-Dialekt sind lange vorbei.

[Faffy]

Zitat:

Zitat von sx2008 (Beitrag 1245368)

Zitat:

Zitat von Insider2004 (Beitrag 1245333)

Schau mal auf Deinen Code. Deiner grünen Kommentare sind länger als der Programmcode. Guter Code braucht keine Kommentare. Benenne Deine Variablen erst mal gescheit.

Das kann ich nur unterstützen!!
Variablen- und Funktionsnamen dürfen wirklich mehr als ein oder zwei Buchstaben lang sein.
Die Zeiten von Sharp Taschenrechner mit ihrem Basic-Dialekt sind lange vorbei.

Ich mag lange Variablen nicht, sondern arbeite lieber mit Abkürzungen und weit rechts am Rand mit vielen Kommentaren. Aber dennoch danke für dein Meinungsbild, ich werde jedoch fortfahren, sodass ich es selbst am Besten finde.

[Faffy]

Zitat:

Zitat von Faffy (Beitrag 1245367)

Perfekt, vielen Dank. Jetzt funktioniert es echt wunderbar, ihr habt mir sehr geholfen.

Eine Frage hätte ich jedoch noch, da mir das nicht ganz klar ist.
Warum muss bei Procedure A

Delphi-Quellcode:

Procedure TCaesar.A (T : String; Var T2 : String; Z : Integer);

Das "Var T2 : String" hinter "T : String;" stehen und bei Procedure B

Delphi-Quellcode:

Procedure TCaesar.B (Var T2 : String; T : String; Z : Integer);

das "Var T2 : String;" eben am Anfang?

Dies hier steht bitte immer noch als zentrale Frage offen, verzeiht mir den Doppelpost, aber ich hatte Angst, dass es so sonst übergangen wird :).

[Medium]

Zitat:

Ich mag lange Variablen nicht, sondern arbeite lieber mit Abkürzungen und weit rechts am Rand mit vielen Kommentaren. Aber dennoch danke für dein Meinungsbild, ich werde jedoch fortfahren, sodass ich es selbst am Besten finde.

Dann wünsche ich viel Freude bei deinen weiteren Forumsfragen, oder sobald du mal mit jemandem anderes zusammen arbeiten musst.

[cookie22]

Zitat:

Zitat von Insider2004 (Beitrag 1245333)

Guter Code braucht keine Kommentare.

Halte ich für ein Gerücht und einen schlechten Tipp für einen Anfänger.

Guter Code kann hoch kompliziert sein, du hättest schreiben sollen: "Einfacher Code braucht keine Kommentare.". Und auch das ist kein guter Stil.

[Klaus01]

Zitat:

Zitat von Faffy (Beitrag 1245367)

Perfekt, vielen Dank. Jetzt funktioniert es echt wunderbar, ihr habt mir sehr geholfen.

Eine Frage hätte ich jedoch noch, da mir das nicht ganz klar ist.
Warum muss bei Procedure A

Delphi-Quellcode:

Procedure TCaesar.A (T : String; Var T2 : String; Z : Integer);

Das "Var T2 : String" hinter "T : String;" stehen und bei Procedure B

Delphi-Quellcode:

Procedure TCaesar.B (Var T2 : String; T : String; Z : Integer);

das "Var T2 : String;" eben am Anfang?

Wie sieht denn die Parameterlist in der Type/Klassen-Deklaration aus?
Grüße
Klaus

[Sir Rufo]

Zitat:

Zitat von Faffy (Beitrag 1245371)

Zitat:

Zitat von sx2008 (Beitrag 1245368)

Zitat:

Zitat von Insider2004 (Beitrag 1245333)

Schau mal auf Deinen Code. Deiner grünen Kommentare sind länger als der Programmcode. Guter Code braucht keine Kommentare. Benenne Deine Variablen erst mal gescheit.

Das kann ich nur unterstützen!!
Variablen- und Funktionsnamen dürfen wirklich mehr als ein oder zwei Buchstaben lang sein.
Die Zeiten von Sharp Taschenrechner mit ihrem Basic-Dialekt sind lange vorbei.

Ich mag lange Variablen nicht, sondern arbeite lieber mit Abkürzungen und weit rechts am Rand mit vielen Kommentaren. Aber dennoch danke für dein Meinungsbild, ich werde jedoch fortfahren, sodass ich es selbst am Besten finde.

Da du aber mit den Abkürzungen augenscheinlich selber nicht klar kommst

Zitat:

Zitat von Uwe Raabe (Beitrag 1245334)

Innerhalb deine Entschlüsselungsmethode hast du die Bedeutung von T und T2 vertauscht.

und du auch noch sachlich falsche Kommentare dort stehen hast

Delphi-Quellcode:

Procedure TCaesar.A (T : String; Var T2 : String; Z : Integer); 
// T = Zu verschlüsselndes Wort
// T2 = Verschlüsseltes Wort
// Z = Irrelevant (Zahl, um die verschoben wird, ist aber nicht angegeben)
Var
 P, Code : Integer; // P = Länge des Wortes, Code = Verschlüsselungscode
 B : String; // B = Buchstabe des Wortes
 B2 : Char; // B2 = Verschobener Buchstabe
Begin
For P := 1 to Length(T) Do
                                Begin
                                  B := Copy(T,P,1);
                                    Code := ORD(B[1]);
                                    Code := Code - Z;

• P ist also die Länge des Wortes, hmmm, im Code sieht das aber nach einem Index aus
• Z ist nicht irrelevant, wenn nicht angegeben, dann dürfte da keine Veränderung passieren (wenn es ein Caesar-Cipher sein soll)

wirst du hoffentlich verstehen, dass ich deinen Standpunkt nur müde belächeln kann.

Ein guter Code ist niemals kompliziert (KISS) und erklärt sich quasi durch den Code selber. Kommentare werden da nur sehr selten benötigt (meistens Quellenangaben für Formeln oder Erläuterungen zu Konstanten).

[Uwe Raabe]

Zitat:

Zitat von Sir Rufo (Beitrag 1245377)

Ein guter Code ist niemals kompliziert (KISS) und erklärt sich quasi durch den Code selber. Kommentare werden da nur sehr selten benötigt (meistens Quellenangaben für Formeln oder Erläuterungen zu Konstanten).

Ich möchte dieses Statement noch um den Fall erweitern, bei dem der Kommentar erklärt, warum man etwas macht. Das ist nämlich nicht immer aus den selbsterklärenden Variablen- und Methodennamen ersichtlich.

[cookie22]

Zitat:

Zitat von Uwe Raabe (Beitrag 1245378)

Ich möchte dieses Statement noch um den Fall erweitern, bei dem der Kommentar erklärt, warum man etwas macht. Das ist nämlich nicht immer aus den selbsterklärenden Variablen- und Methodennamen ersichtlich.

Gerade wenn man mit Code zu tun hat, den man nicht selbst geschrieben hat sind Komentare sehr wichtig. "Ein guter Code ist niemals kompliziert." Das halte ich wie schon gesagt für ein Gerücht.

[Sir Rufo]

Zitat:

Zitat von cookie22 (Beitrag 1245396)

Zitat:

Zitat von Uwe Raabe (Beitrag 1245378)

Ich möchte dieses Statement noch um den Fall erweitern, bei dem der Kommentar erklärt, warum man etwas macht. Das ist nämlich nicht immer aus den selbsterklärenden Variablen- und Methodennamen ersichtlich.

Gerade wenn man mit Code zu tun hat, den man nicht selbst geschrieben hat sind Komentare sehr wichtig. "Ein guter Code ist niemals kompliziert." Das halte ich wie schon gesagt für ein Gerücht.

Welches du uns gerne mit einem konkreten Beispiel zeigen darfst, welches wir dann seinerseits mit den von uns genannten Vorgaben widerlegen werden :)

Ist der Code einer Routine/Methode zu kompliziert, dann macht dieser Codeteil einfach zu viel -> zerlegen in kleinere Routinen/Methoden

[cookie22]

Zitat:

Zitat von Sir Rufo (Beitrag 1245400)

Welches du uns gerne mit einem konkreten Beispiel zeigen darfst, welches wir dann seinerseits mit den von uns genannten Vorgaben widerlegen werden :)

Ist der Code einer Routine/Methode zu kompliziert, dann macht dieser Codeteil einfach zu viel -> zerlegen in kleinere Routinen/Methoden

Du gehst hier aber vom Idealfall aus, nicht von der Realität. Wenn man in Teams mit vielen Leuten an einer Code-Base arbeitet, dann hat man viele Leute, die in einem Topf rühren. Wenn da nicht kommentiert wird, findet sich da niemand mehr zurecht. Dann hat man viele Programmierer mit unterschiedlichem Skill-Level. Das, was einer leicht versteht, sind für andere böhmische Dörfer. Es geht auch sicher nicht darum, jede einzelne Zeile zu kommentieren, aber den Sinn einer Sache oder bestimmte Zusammenhänge sollte man schon kommentieren. Das kann viel Zeit sparen.

Aber ich glaub das ist schon wieder OT. :P

[dataspider]

Wenn du warnst, Anfängern nicht solche Tipps wie: guter Code braucht keine Kommentare" zu geben, dann ist das deine Sicht.

Ich wäre heute glücklich, wenn ich damals als Anfänger solche Hinweise bekommen hätte.
Denn erst gerade diese Regeln (sehr gut beschrieben in Clean Code) haben mir tatsächlich nennenswerte Zeit erspart.
Zeit, die ich mit Kommentaren niemals sparen kann sondern wohl eher verschwende.

Und wer es einmal erlebt hat, Code wie ein Buch zu lesen, der wird diese Regel niemals mehr in Frage stellen.

Frank

[cookie22]

"Guter Code braucht keine Kommentare." Ist aus meiner Sicht ein schlechter Tipp, gerade für Anfänger, weil ein Anfänger wohl kaum den Durchblick hat, ob etwas sauber programmiert ist oder nicht. Das verführt nur dazu "schlecht Code" nicht auszukommentieren. Ich schlage mich täglich mit solchem Mist herum, wo ich mir denke, was hat der Typ sich hierbei nur gedacht. Dann geht das große Rätselraten los, obwohl eine Kommentarzeile schon alles hatte erklären können. Besonders toll ist so etwas bei Workarounds, welche einem völlig Sinnfrei erscheinen ohne Kommentar.

Vielleicht können wir uns auf: "Guter Code braucht wenig Kommentare." einigen. ;)

[Uwe Raabe]

Es könnte hier der Eindruck enstehen, Kommentare seien das neue GOTO oder WITH. Dem ist nun wahrlich nicht so!

[Sir Rufo]

Hier mal der Caesar-Cipher der fast keine Kommentare benötigt

Delphi-Quellcode:

unit Caesar;

interface

type

  // siehe http://de.wikipedia.org/wiki/Caesar-Verschlüsselung

  TCaesarCipher = class
  private const
    CCharCount = 26; // 26 Buchstaben im Alphabet
    CFirstPlainChar = 'a'; // Klartext in Kleinbuchstaben und startet mit 'a'
    CFirstCryptChar = 'A'; // Geheimtext in Großbuchstaben und startet mit 'A'
  private
    function GetPositiveShift( AShift : Integer ) : Integer;
    function GetShiftedCode( ACode, AShift : Integer ) : Integer;
  public
    function Encrypt( const APlainStr : string; AShift : Integer ) : string;
    function Decrypt( const ACryptStr : string; AShift : Integer ) : string;
  end;

implementation

{ TCaesarCipher }

function TCaesarCipher.GetPositiveShift( AShift : Integer ) : Integer;
begin
  Result := AShift mod CCharCount; // -CCharCount+1 .. CCharCount-1
  Result := Result + CCharCount; // 1 .. 2*CCharcount-1
  Result := Result mod CCharCount; // 0 .. CCharCount-1
end;

function TCaesarCipher.GetShiftedCode( ACode, AShift : Integer ) : Integer;
begin
  // Bei einer festen Anzahl x ist es egal, ob man 2 zurück oder (x-2) vor geht
  // Start ....... : 1(2)3 4 5
  // 2 zurück .... : 1 2 3 4(5)
  // (5-2) = 3 vor : 1 2 3 4(5)
  Result := ( ACode + GetPositiveShift( AShift ) ) mod CCharCount;
end;

function TCaesarCipher.Decrypt( const ACryptStr : string; AShift : Integer ) : string;
var
  LStrLength : Integer;
  LStrIndex : Integer;
  LPlainChar : Char;
  LCryptChar : Char;
  LPlainCode : Integer;
  LCryptCode : Integer;
begin
  LStrLength := Length( ACryptStr );
  SetLength( Result, LStrLength );
  for LStrIndex := 1 to LStrLength do
  begin
    LCryptChar := ACryptStr[LStrIndex];
    LCryptCode := Ord( LCryptChar ) - Ord( CFirstCryptChar );
    { TODO : Überprüfung von 0 <= LCryptCode < CCharCount }
    LPlainCode := GetShiftedCode( LCryptCode, - AShift );
    LPlainChar := Char( LPlainCode + Ord( CFirstPlainChar ) );
    Result[LStrIndex] := LPlainChar;
  end;
end;

function TCaesarCipher.Encrypt( const APlainStr : string; AShift : Integer ) : string;
var
  LStrLength : Integer;
  LStrIndex : Integer;
  LPlainChar : Char;
  LCryptChar : Char;
  LPlainCode : Integer;
  LCryptCode : Integer;
begin
  LStrLength := Length( APlainStr );
  SetLength( Result, LStrLength );
  for LStrIndex := 1 to LStrLength do
  begin
    LPlainChar := APlainStr[LStrIndex];
    LPlainCode := Ord( LPlainChar ) - Ord( CFirstPlainChar );
    { TODO : Überprüfung von 0 <= LPlainCode < CCharCount }
    LCryptCode := GetShiftedCode( LPlainCode, AShift );
    LCryptChar := Char( LCryptCode + Ord( CFirstCryptChar ) );
    Result[LStrIndex] := LCryptChar;
  end;
end;

end.

Wie man sieht benötigt man keine Kommentare um die Funktionsweise des Codes trotzdem lesbar zu gestalten.
Die Funktionsweise des Caesar-Ciphers muss man aber schon vorher verstanden haben.

Ein Code ist schließlich nicht dazu da eine Thematik zu erklären, sondern die Thematik umzusetzen.
Wer die Thematik verstanden hat, sollte dann auch den Code verstehen können.

HINWEIS
Der Code ist bewusst nicht DRY ...