PureBoard

Hi,
ich hatte einfach mal Lust, ein einfaches Programm zu schreiben, dass Worte verschlüsselt. Es funktioniert auch, allerdings habe ich den Base64Encoder benutzt. Schon bei kurzen Worten wie "hallo" kommt nicht das selbe heraus, wie am Anfang, bei "hallo" z.B. "halso".Daher wollte ich etwas anderes versuchen und den Cäsar-Code benutzen. Dabei werden alle Buchstaben um eine Zahl, die als "Schlüssel" benutzt wird, verschoben. Aus a wird b, aus b wird c usw.

Mein Programm sollte den ASCII-Wert ermitteln und in einer Variable speichern. Ein bestimmter Wert sollte addiert oder substrahiert werden. Anschließend sollten die Zahlen wieder in Buchstaben umgewandelt werden.
Bis jetzt bin ich noch nicht zu einem "richtigen" Ergebnis gekommen. Gedacht habe ich mir, dass mit dem Befehl Asc der Wert ermittelt und in einer Variable gespeichert werden soll. Das Wort wird dann Buchstabe für Buchstabe abgearbeitet und dann wird gerechnet. Anschließend wird wieder umgewandelt (wie weiß ich nicht).

Bisheriges Ergebnis: a$ ist der String, in dem der eingegebene Text gespeichert wird. ascii ist die Variable, in der der ASCII-Wer gespeichert wird.

Da ich nicht genau weiss, wie weit du bist, ein paar Vorschläge:
1. Du gehst mit den Stringoperationen Zeichen für Zeichen durch den String und liest den ASCII Wert aus. Am besten direkt in eine Byte Variable. Dann nurnoch die Verschiebung drauf addieren und das ganze Zurück (mit chr()) in einen String packen. Ich denke dies ist die "intuitivere" Variante.
2. Das ganze direkt im Speicher. Funktioniert quasi wie oben. Kleines Bsp: Dies ist quasi der direkte Weg.
@text liefert einen Pointer auf den String. Da Strings auch nur aneinander Reihungen von Bytes sind, liefert @text das erste Byte des Strings. Dies ist derselbe Wert, wie wenn du asc() auf das erste Zeichen anwendest.
Nun wandert man durch den Speicher @text+a und erhält das a-te Zeichen.
Da Bytes automatisch einen Variablen Überlauf haben (Wert von 255 wird überschritten -> bei 0 gehts weiter) können wir nun einfach ohne Gedanken zu machen draufaddieren.

Ich hoffe das hilft dir

ich glaub ich lasse jetzt erstmal einen

@ gnasen:

Wofür gibt es dann PeekC()?
Bitte Anfängern gleich den richtigen Weg zeigen!!

wenn schon ansprechen, dann auch erklären:

PeekC peekt exakt einen Char.
bei unicode sind das zwei byte, bei ascii eins, außerdem wird der Wert, wenn man ihn auch in einer .c variable ablegt, unsigned behandelt, ein byte dagegen ist immer signed, also -128 bis 127.

AND51 hat geschrieben:Wofür gibt es dann PeekC()?
Bitte Anfängern gleich den richtigen Weg zeigen!!

Danke, stimmt, habe ich nicht dran gedacht. Ich selbst benutze chars sehr selten, daher das Byte. Habe es oben mal berichtigt.

Edit: So nun sollte es aber berichtigtrichtigt sein

gnasen hat geschrieben:Habe es oben mal berichtigt.

Aber nur Teilweise
byte.c oder besser den variablennamen auch ändern

Was ich nun gemacht habe: "*String" ist eine Variable, die auf eine Adresse zeigt. Dies bedeutet, dass ich mittels dieser Variable auf den Inhalt eines jeweiligen Speicherbereichs zugreifen kann. Man nennt diese Variablen auch Zeiger (haben immer ein Sternchen vor dem Name). Der Typ ".Character" gibt an, dass wir mit Hilfe dieses Zeigers auf Buchstaben/Zeichen zugreifen wollen.

Nun kommen wir zur zweiten Zeile: Wenn wir eine Variable vom Typ String übergeben, so wird unser Zeiger auf die Adresse des ersten Buchstabens gesetzt. Wir wollen nun diesen Zeiger über alle Buchstaben springen lassen und zugleich den ASCII-Wert um eins erhöhen (dies macht "*String\C + 1"). Da Jeder String mit einem ASCII-0 endet, können wir eine While-Schleife verwenden, die checkt ob der ASCII-Code Null ist oder nicht. Somit springen wir nicht über das Ende des Strings hinaus.

In der dritten Zeile wird durch "*String\C" auf den ASCII-Wert des aktuellen Buchstabens zugegriffen. Durch "+ 1" erhöhen wir wie bereits erwähnt den ASCII-Wert um eins.

Die letzte Zeile innerhalb der While-Schleife verschiebt nun die Adresse um ein Zeichen weiter. Da der Compiler auch Unicode (2 Bytes) unterstützt, addieren wir mit "SizeOf(Character)", dessen Wert sich nach den Compileroptionen anpasst. D.h. bitte nicht einen Zeiger auf eine Zeichenkette mit "+ 1" verschieben.

Jetzt kommen wir zur verwendung der "Convert"-Prozedur: Zuerst definieren wir eine Variable mit dem Wert "sdrs", wie oben im Beispiel. Da die Prozedur eine Adresse auf den ersten Buchstaben einer Zeichenkette benötigt, müssen wir nun als Parameter "@MyString" angeben. Das Ergebnis ist direkt im Inhalt der Variable enthalten, da wir direkt durch "*String\C" auf den Inhalt der Variable zugegriffen und diesen auch modifiziert haben.

Veranschaulichung:
MyString.s = "sdrs"
Im Speicher:
S, D, R, S, NULL

*String.Character = @MyString
<S>, D, R, S, NULL
*String\C + 1
<T>, D, R, S, NULL
*String + SizeOf(Character)
T, <D>, R, S, NULL
usw...

Ich hoffe, dass das weiter geholfen hat.

Habe mal gerade lust gehabt ein kleines Tutorial für Stringpointers zu schreiben.
Gruß Josef

Josef Sniatecki hat geschrieben: Habe mal gerade lust gehabt ein kleines Tutorial für Stringpointers zu schreiben.
Gruß Josef

Sehr schön gemacht, solche Tuts sind immer nützlich.

Aber den Vorteil des ganzen haste nicht erwähnt
Es ist erheblich schneller, falls es mal auf Speed ankommt,
die Fehlerwahrscheinlichkeit, wenn man solche Codes schreibt ist
natürlich auch größer.