Von der Grundstufe bis zur Mittelstufe: Arrays und Zeichenketten (II)

Einführung

Der hier dargestellte Inhalt ist ausschließlich für Bildungszwecke bestimmt. Die Anwendung sollte unter keinen Umständen zu einem anderen Zweck als zum Erlernen und Beherrschen der vorgestellten Konzepte verwendet werden.

Im vorigen Artikel, Von der Grundstufe zur Mittelstufe: Arrays und Zeichenketten (I), haben wir eine kurze Einführung in Zeichenketten (string) und Arrays gegeben, obwohl dieser Artikel in der Praxis fast ausschließlich auf Strings ausgerichtet war. Alles, was dort behandelt wurde, diente nur als eine leichte und prägnante Einführung in das Thema. Damit wir jedoch zu anderen Themen übergehen können, müssen wir zunächst etwas tiefer in die vorangegangenen Erklärungen eindringen. Daher ist die Voraussetzung für das Verfolgen und Verstehen des in diesem Artikel vorgestellten Materials, dass man den Inhalt des vorherigen Artikels verstanden hat.

Neben dieser Grundvoraussetzung gibt es weitere, die ebenso wichtig sind, wie z. B. das Verständnis der IF-Anweisung und der Schleifenkonstruktionen sowie eine gewisse Kenntnis der Operatoren und Variablen. Alle diese Themen sollten Ihnen vertraut sein, wenn Sie die vorherigen Artikel gelesen haben. Sollte dies nicht der Fall sein, empfiehlt es sich, das frühere Material zu lesen, um zu verstehen, was hier besprochen wird.

Nun können wir uns dem Hauptthema dieses Artikels zuwenden. Hier ist unser neues Thema.

Nutzerdefinierte Formatierung

Einer der angenehmsten Aspekte der Programmierung in MQL5 ist, dass wir uns oft nicht darum kümmern müssen, bestimmte Dinge von Grund auf neu zu erstellen. In der Tat kommt es selten vor, dass die MQL5-Standardbibliothek unsere Anforderungen nicht erfüllt. Es gibt jedoch Situationen, in denen es nicht ganz dem entspricht, was wir brauchen oder wollen. Ein solcher Fall ist die Erstellung von nutzerdefinierten Formatierungen zur Anzeige bestimmter Arten von Informationen, sei es im Terminal oder in einem grafischen Objekt, das wir verwenden wollen.

Da wir in diesem Stadium noch nicht mit grafischen Objekten arbeiten werden, konzentrieren sich alle unsere Aufgaben auf die Verwendung der Standardausgabe von MetaTrader 5, d.h. des Terminals. Ich werde Ihnen bald zeigen, wie Sie die Dinge viel interessanter gestalten können. Doch bis es so weit ist, müssen wir zunächst ein solides und gefestigtes Verständnis für einige wichtige Merkmale einer Programmiersprache aufbauen.

Daher ist dieser erste Inhalt nicht ausschließlich an MQL5 gebunden. Es kann auch in anderen Programmiersprachen angewendet werden, insbesondere in den Teilen, die sich mit Programmierkonzepten und -regeln befassen. Wie zu Beginn dieses Themas erwähnt, gibt es Szenarien, in denen die MQL5-Standardbibliothek nicht ausreichend ist. Aber mit dem Wissen aus den vorangegangenen Artikeln und ein wenig logischem Denken lassen sich viele interessante Dinge umsetzen, auch wenn wir auf den ersten Blick nur grundlegende Themen behandelt haben, die vielleicht keinen klaren Zweck zu haben scheinen.

Der Akt, einem bestimmten Wissen einen Zweck zuzuweisen, ist an sich nicht der aufregendste Teil der Arbeit eines Programmierers. Der wirklich interessante Teil liegt in dem Moment, in dem man zu verstehen beginnt, wie die Dinge funktionieren, und anfängt, darüber nachzudenken, wie man dieses Wissen zur Lösung eines bestimmten Problems einsetzen kann. Das ist der Moment, in dem das Lernen wirklich an Bedeutung gewinnt.

Nun möchte ich Sie bitten, sich folgendes Problem zu überlegen. Angenommen, Sie möchten Binärwerte im MetaTrader 5-Terminal anzeigen oder drucken. Der Grund spielt keine Rolle, nur das Problem selbst. Sie stehen also vor dieser Herausforderung und denken sofort: „Nun, ich kann die String-Formatierung verwenden, um binäre Werte im Terminal anzuzeigen“. Perfekt, das wäre ein solider erster Gedanke eines guten Programmierers. Ein erfahrener Programmierer würde die Antwort jedoch bereits kennen. Ein Anfänger hingegen könnte in der Dokumentation nach einer Möglichkeit suchen, eine Zeichenkette so zu formatieren, dass sie die binäre Darstellung eines numerischen Wertes anzeigt, und wird feststellen, dass eine solche Funktion nicht existiert. Und genau in diesem Moment brauchen wir Kreativität in Kombination mit Wissen.

Da es kein eingebautes Format für die Anzeige von Binärwerten gibt, müssen wir ein eigenes erstellen. Wenn Sie neu in der Programmierung sind und nur über die in den vorangegangenen Artikeln beschriebenen Kenntnisse verfügen, könnten Sie annehmen, dass dies unmöglich ist. Aber ist es das wirklich, lieber Leser? Mal sehen, ob es möglich ist, nur die in früheren Artikeln enthaltenen Informationen zu verwenden.

Wir wissen, dass es in der Standardbibliothek eine Funktion gibt, mit der wir verschiedene Arten von Daten formatieren können. Alles, was wir tun müssen, ist, unser eigenes Format für die Verarbeitung von Binärwerten zu erstellen. Dies ist der einfachste Teil, aber es gibt noch eine schwierigere Aufgabe. Im Gegensatz zu C oder C++, wo eine unbegrenzte Anzahl von Argumenten an eine Funktion übergeben werden kann, bietet MQL5 diese Flexibilität nicht. Soweit ich weiß, sind C und C++ die einzigen Sprachen, die eine solche Funktionalität zulassen, aber seien wir ehrlich, niemand ist so verrückt, etwas in Assembly zu schreiben. Offen gesagt, wäre das ein Zeichen von Wahnsinn.

Na gut. Die Unmöglichkeit, einer Funktion eine unbegrenzte Anzahl von Argumenten zu übergeben, lässt die Dinge zunächst komplizierter erscheinen. Aber wir können das Problem in überschaubare Schritte unterteilen. Da wir ein neues Format erstellen und gleichzeitig ein bestehendes Format aus der MQL5-Bibliothek verwenden wollen, können wir die Daten entsprechend manipulieren. Wie? Ganz einfach, lieber Leser. Wir erstellen eine Funktion, die eine Zeichenkette zurückgibt, die die binäre Darstellung eines Wertes enthält. Da die MQL5-Standardbibliothek bei der Formatierung der Ausgabe mit Strings arbeiten kann, ist es einfach zu definieren, was effektiv unser nutzerdefiniertes Format sein wird.

Wenn man es so sieht, mag es eine schwierige Aufgabe sein. Wie einfach das ist, sehen Sie am folgenden Code:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar value = 138;
07. 
08.     PrintFormat("The value %d in binary is written as: %s", value, BinaryToString(value));
09. }
10. //+------------------------------------------------------------------+
11. string BinaryToString(const uchar arg)
12. {
13.     return "--BINARY--";
14. }
15. //+------------------------------------------------------------------+

Code 01

Wenn wir Code 01 ausführen, sieht das Ergebnis wie folgt aus:

Abbildung 01

An dieser Stelle könnten Sie denken: „Wow, das ist aber nicht das, was wir umsetzen wollten“. Das ist in der Tat nicht das, was wir wollten. Aber das soll Ihnen zeigen, dass wir auf dem Bestehenden aufbauen und versuchen können, etwas Neues zu schaffen. Beachten Sie, dass die Textzeichenfolge in Zeile 13 dieselbe ist wie in Abbildung 01. Mit anderen Worten: Es funktioniert.

Jetzt müssen wir nur noch den von der Funktion empfangenen Wert in eine binäre Darstellung umwandeln. Anschließend fügen wir diese Darstellung in eine Zeichenkette ein und geben sie zurück. Wir tun dies in Zeile 13.

Wie können wir den resultierenden Wert in eine Zeichenkette umwandeln, die nur Nullen und Einsen enthält? Es ist alles ganz einfach, liebe Leser. Hierfür verwenden wir eine Schleife. Es gibt jedoch einen kleinen Punkt. Aber ich werde es direkt im Code erklären, der unten zu sehen ist:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar value = 138;
07. 
08.     PrintFormat("The value %d in binary is written as: %s", value, BinaryToString(value));
09. }
10. //+------------------------------------------------------------------+
11. string BinaryToString(const uchar arg)
12. {
13.     string  sz0 = "";
14.     uchar   mask = 0x80;
15. 
16.     while (mask)
17.     {
18.         sz0 = sz0 + ((arg & mask) == mask ? "1" : "0");
19.         mask = mask >> 1;
20.     }
21. 
22.     return sz0;
23. }
24. //+------------------------------------------------------------------+

Code 02

Wenn Sie diesen Code ausführen, sehen Sie die folgende Ausgabe im MetaTrader 5 Terminal:

Abbildung 02

Es ist absolut perfekt. Mit anderen Worten: Mit minimalen und grundlegenden Kenntnissen konnten wir die Aufgabe bewältigen. Allerdings gibt es ein kleines Detail in diesem Code. Ausgehend von den bisher gezeigten Erkenntnissen, wir können nicht einfach irgendeine Art von Daten verwenden, um sie in ihre binäre Darstellung umzuwandeln. Dies wäre nicht möglich, ohne sich mit fortgeschrittenen Programmierkonzepten zu befassen. Das heißt, für einfache Fälle, in denen wir mit einem einzigen Datentyp arbeiten - in diesem Fall uchar. Wir haben bereits eine Funktion, die effektiv funktioniert. Und wie Sie sehen können, ist es ganz einfach. Da alles, was hier getan wird, bereits in früheren Artikeln behandelt wurde, brauche ich nicht zu erklären, wie diese Funktion ihre Aufgabe erfüllt. Es gibt jedoch einen Operator, der verwendet wird, den wir noch nicht besprochen haben: den Shift-Operator. Da sie in der Funktion vorkommt, halte ich es für sinnvoll, ihre Funktionsweise zu erklären. Dies wird der Schwerpunkt des nächsten Abschnitts sein. Bevor wir jedoch weitermachen, möchte ich Sie auf ein wichtiges Detail aufmerksam machen: Die Variable „mask“ muss die gleiche Bitbreite haben wie die Variable „arg“. Dies gewährleistet eine korrekte und genaue Umrechnung und Übersetzung der Werte. Mit der Veröffentlichung fortgeschrittener Artikel werden wir lernen, wie der Compiler diesen Aspekt für uns erledigen kann. So können wir jeden Datentyp verwenden, vom komplexesten bis zum einfachsten, ohne dass wir viel an der in Code 02 gezeigten Funktion ändern müssen. Aber das ist ein Thema für die Zukunft. Jetzt wollen wir erst einmal lernen, wie der Shift-Operator funktioniert. Wenden wir uns also einem neuen Thema zu.

Der Operator Shift

Die Operatoren sind im Allgemeinen selbsterklärend. Der Shift-Operator kann jedoch für manche Menschen etwas verwirrend sein, da er hauptsächlich im Zusammenhang mit Computern verwendet wird. Soweit ich weiß, kommt sie außerhalb der Informatik und der digitalen Elektronik nicht vor. Der Shift-Operator, der in Zeile 19 von Code 02 zu sehen ist, ist sehr praktisch und in vielen Fällen sehr nützlich. Es handelt sich jedoch NICHT um einen speziellen Operator, da er lediglich als Abkürzung für andere Operationen dient und in der Regel zwei ausführlichere Operatoren ersetzt, die Sie in einem bestimmten Code wahrscheinlich finden werden. Ich sage „zwei“, weil es tatsächlich zwei Verschiebeoperatoren gibt: einen für die Verschiebung nach rechts und einen für die Verschiebung nach links. Viele Anfänger verwechseln diese Verschiebungsoperatoren mit relationalen Operatoren, die zum Vergleich von Werten verwendet werden, z. B. größer als oder kleiner als. Diese Verwirrung rührt in der Regel von mangelnder Aufmerksamkeit her, da Umschaltoperatoren aus Doppelpfeilen (entweder links oder rechts) bestehen, während relationale Operatoren einfache Pfeile verwenden.

Was genau macht der Shift-Operator also? Er gibt an, um wie viele Bits ein bestimmter Wert nach links oder rechts verschoben werden soll. Das mag zunächst etwas kompliziert klingen, ist aber viel einfacher als die Vorgänge, um sie zu ersetzen. 

Aber was bedeutet das? Das verstehe ich nicht. Wenn es eine andere Möglichkeit gibt, das Gleiche auszudrücken, warum verwenden wir dann nicht diese? Das ist eine berechtigte Frage. Ich kann es Ihnen zeigen. Das ist genau der Grund, warum ich diesen Abschnitt schreibe. Ich möchte, dass Sie verstehen, dass das gleiche Ergebnis durch verschiedene Umsetzungen erreicht werden kann. Es ist höchst unwahrscheinlich, dass zwei Programmierer die exakt gleiche Lösung für ein Problem gefunden haben. Nicht unmöglich, aber definitiv selten. Das liegt daran, dass die Art und Weise, wie ein Problem gelöst wird, oft vom Wissensstand und der Erfahrung der einzelnen Programmierer abhängt.

Kehren wir nun zu unserem Hauptthema zurück. Um klar und einfach zu erklären, wie Shift-Operatoren funktionieren, werden wir mit dem unten gezeigten Code herumspielen.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const uchar shift = 1;
07.     uchar   i0 = 153,
08.             i1,
09.             i2,
10.             i3,
11.             i4;
12. 
13.     i1 = i0 << shift;
14.     i2 = i0 * (uchar)MathPow(2, shift);
15.     i3 = i0 >> shift;
16.     i4 = i0 / (uchar)MathPow(2, shift);
17. 
18.     PrintFormat("Shift value          : %d\n" + 
19.                 "Original             : %s\t%d\n" +
20.                 "Shifted to the left  : %s\t%d\n" +
21.                 "Multiplication result: %s\t%d\n" +
22.                 "Shifted to the right : %s\t%d\n" +
23.                 "Division result      : %s\t%d"
24.                 , shift, BinaryToString(i0), i0, 
25.                          BinaryToString(i1), i1, 
26.                          BinaryToString(i2), i2, 
27.                          BinaryToString(i3), i3, 
28.                          BinaryToString(i4), i4
29.                 );
30. }
31. //+------------------------------------------------------------------+
32. string BinaryToString(const uchar arg)
33. {
34.     string  sz0 = "";
35.     uchar   mask = 0x80;
36. 
37.     while (mask)
38.     {
39.         sz0 = sz0 + ((arg & mask) == mask ? "1" : "0");
40.         mask = mask >> 1;
41.     }
42. 
43.     return sz0;
44. }
45. //+------------------------------------------------------------------+

Code 03

Wenn Sie diesen Code ausführen, erhalten Sie die in der folgenden Abbildung dargestellte Ausgabe:

Abbildung 03

Passen Sie jetzt gut auf, liebe Leserin, lieber Leser. Dieser Code 03, der auf den ersten Blick recht verwirrend erscheinen mag, ist in Wirklichkeit sehr klar und erfüllt diesen Zweck effektiv. Aber um sie vollständig zu verstehen, müssen Sie wissen, was die Funktion MathPow tut. Da es Teil der MQL5-Standardbibliothek ist, empfehle ich, die offizielle Dokumentation für weitere Details zu lesen. Kurz gesagt, sie führt einfach eine Potenzierung durch. Sie gibt jedoch einen doppelten Wert zurück. Da unsere Daten vom Typ uchar sind, wird der Typ explizit „gecastet“. Dadurch wird verhindert, dass sich der Compiler über nicht übereinstimmende Datentypen beschwert.

Beachten Sie nun, dass in Abbildung 03 in jeder Zeile sowohl der Wert als auch seine binäre Darstellung angezeigt werden. Diese binäre Darstellung ist wichtig, weil sie klarer macht, was mit unserem ursprünglichen Wert geschieht. Man könnte sagen, dass das Verschieben eines Wertes nach links ihn mit zwei multipliziert und das Verschieben nach rechts ihn durch zwei teilt. In gewisser Weise haben Sie nicht Unrecht: Das heißt, wenn wir nur die Abbildung 03 analysieren. Aber was passiert, wenn wir die Anzahl der Schichten von beispielsweise eins auf drei ändern?

Abbildung 04

Abbildung 04 zeigt, was passiert, wenn wir uns um drei Positionen verschieben. In diesem Fall könnte Ihnen etwas Merkwürdiges auffallen. Eine Verschiebung um drei bedeutet nicht, dass wir einfach mit zwei multiplizieren oder dividieren, sondern dass wir mit Potenzen von zwei arbeiten. Das heißt, wir dividieren oder multiplizieren mit zwei, um eine bestimmte Zahl zu erhalten. Das korrekte Ergebnis wird genau durch die Verwendung des Shift-Operators erreicht. Da die Durchführung dieser Art von Operationen (mit Potenzierung und anschließender Multiplikation oder Division) rechenintensiver ist, sollte stattdessen der Verschiebeoperator verwendet werden.

Wenn Sie jedoch die Werte in Abbildung 04 betrachten, werden Sie feststellen, dass ein Teil der Informationen verschwindet. Dies ist kein Fehler im Programm, lieber Leser. Das ist eine Folge der Datentypbeschränkungen. MQL5 ist eine stark typisierte Sprache, und wenn wir die Grenzen eines Typs überschreiten, gehen einige Informationen verloren. Es gibt verschiedene Möglichkeiten, dies zu vermeiden oder zu umgehen, aber das ist im Moment nicht unser Thema. Wir werden zu einem späteren Zeitpunkt darüber sprechen, wie diese Fälle zu behandeln sind. Und glauben Sie mir, beim Programmieren gibt es immer etwas zu lernen.

Ich glaube, es ist jetzt klar, wie der Shift-Operator funktioniert. Mit diesem Verständnis sollte der Code 02 nun leicht zu verstehen sein. Wir können nun zu einem anderen Thema übergehen, das noch etwas mit Strings und Arrays zu tun hat.

Pangramm und Anagramm

Es gibt eine interessante und manchmal sogar lustige Anwendung, die wir an dieser Stelle erforschen können, selbst mit dem begrenzten Material, das wir bis jetzt behandelt haben. Ich spreche von Pangrammen. Ein Pangramm ist ein Satz, der alle Buchstaben des Alphabets enthält und oft zu Testzwecken verwendet wird. Obwohl es sich um ein ziemlich altes Konzept handelt, ist es eine sehr didaktische und ansprechende Übung. Das vielleicht bekannteste englische Pangramm von allen ist:

A QUICK BROWN FOX JUMPS OVER THE LAZY DOG 0123456789

Dieser Satz wurde ursprünglich verwendet, um alte Telegrafiesysteme zu testen. Sie enthält alle Zeichen, die in einer Nachricht vorkommen können. Noch berühmter wurde sie jedoch dadurch, dass Microsoft sie in Word für die Druckvorschau von Text verwendete. Damals behaupteten einige Leute sogar, dass in den Microsoft-Tools versteckte Botschaften enthalten seien, was vielen Nutzern Angst vor der Verwendung von Computern machte.

Aber auch im Rahmen dessen, was wir gerade besprechen, können wir mit dieser Art von Sätzen spielen. So können Sie mehr über Zeichenketten und Arrays lernen. Es ist einfach und sehr unterhaltsam, und ich glaube, es wird Ihnen Spaß machen zu lernen, wie es funktioniert.

Es ist nicht ungewöhnlich, dass Leute sagen, wir sollten starke Passwörter oder sogar ganze Sätze als Passwörter verwenden. Aber es ist oft schwierig, sichere Passwörter zu erstellen oder sie sich zu merken. Andererseits empfehlen viele, spezielle Software zum Speichern von Passwörtern zu verwenden. Wenn diese Tools jedoch ein Hauptpasswort erfordern, um auf alle anderen zugreifen zu können, finde ich persönlich das nicht besonders hilfreich.

Aber auch ein Anfänger, der versteht, wie grundlegende Funktionen und Befehle funktionieren, kann ein einfaches Tool erstellen, um ein relativ sicheres Passwort zu generieren. Natürlich hängt die Stärke des Kennworts vom System und dessen Aufbau ab. Aber mit ein bisschen Kreativität, liebe Leserin, lieber Leser, können Sie sich bestimmt etwas Interessantes einfallen lassen, zumal das Ziel hier rein pädagogisch ist.

Lassen Sie uns mit folgenden Überlegungen beginnen: Was ist ein Passwort? Nun, ein Passwort ist im Wesentlichen eine Reihe von druckbaren Zeichen, die in einer Zeichenkette gespeichert sind. Wenn wir also eine Zeichenkette nehmen und sie manipulieren, können wir ein Programm erstellen, das die Zeichenkette mischt oder verschlüsselt. Da das Ziel darin besteht, ein sicheres Kennwort zu erstellen, kann dieses Durcheinandermischen, das eine Form der Verschlüsselung oder einfach ein Anagramm sein kann, das ursprüngliche Kennwort zumindest teilweise verbergen. Allerdings eignen sich Anagramme nicht besonders gut, um sensible Informationen wie ein Passwort zu verstecken, das an anderer Stelle verwendet werden soll. In diesem Fall ist das Mischen oder Verschlüsseln eine bessere Option, wobei ein Anagramm oder Pangramm als Basisphrase verwendet wird. Der Schlüssel wäre ein Satz, den Sie sich leicht merken können, und das Endergebnis wäre das von Ihnen verwendete Passwort.

Damit Sie besser verstehen, was ich beschreibe, sehen wir uns ein einfaches und unprätentiöses Stück Code an. Sie können es gleich unten sehen:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string sz_Secret_Phrase = "Um pequeno jabuti xereta viu dez cegonhas felizes";
07. 
08.     Print("Result:\n", PassWord(sz_Secret_Phrase));
09. }
10. //+------------------------------------------------------------------+
11. string PassWord(const string szArg)
12. {
13.     const string szCodePhrase = "The quick brown fox jumps over the lazy dog";
14. 
15.     string  szPsw = "";
16.     uchar   pos;
17. 
18.     for (int c = 0; c < StringLen(szArg); c++)
19.     {
20.         pos = (uchar)(StringGetCharacter(szArg, c) % StringLen(szCodePhrase));
21.         szPsw = StringFormat("%s%c", szPsw, StringGetCharacter(szCodePhrase, pos));
22.     }
23. 
24.     return szPsw;
25. }
26. //+------------------------------------------------------------------+

Code 04

Wenn Sie sich diesen Code ansehen, werden Sie vielleicht denken: Was in aller Welt wollen Sie hier erreichen? Entspannen Sie sich, lieber Leser. Was wir hier tun, mag auf den ersten Blick ein wenig verrückt und unsinnig erscheinen. Aber bald wirst du genau verstehen, was ich dir zu zeigen versuche. Bedenken Sie Folgendes: In diesem Code wird nur das verwendet, was wir bis jetzt behandelt haben. Hier wird nichts Neues eingeführt. Sie werden alles verstehen, wenn Sie die vorangegangenen Artikel gelesen haben und sich die Zeit nehmen, die in diesem Beispiel verwendeten Bibliotheksfunktionen zu studieren. Alles hier beruht auf Funktionen, die in der MQL5-Dokumentation leicht zu finden sind. Daher werde ich nicht im Detail auf die verwendeten Funktionen eingehen. Wenn Sie diesen Code jedoch ohne Änderungen ausführen, erhalten Sie die folgende Ausgabe:

Abbildung 05

Der in Abbildung 05 hervorgehobene Bereich stellt das Passwort dar, das Sie verwenden sollten. Es ist jedoch zu beachten, dass es aufgrund der vorhandenen Leerzeichen etwas fehlerhaft ist. Normalerweise enthalten Passwörter keine Leerzeichen. Wir müssen dies also korrigieren. Eine sehr einfache Möglichkeit, dies zu beheben, besteht darin, die Leerzeichen zu entfernen und den ersten Buchstaben groß zu schreiben. Dies ist recht einfach zu erreichen. Nach dieser Änderung in Zeile 13 von Code 04 erhalten wir einen ähnlichen Code wie den folgenden:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string sz_Secret_Phrase = "Um pequeno jabuti xereta viu dez cegonhas felizes";
07. 
08.     Print("Result:\n", PassWord(sz_Secret_Phrase));
09. }
10. //+------------------------------------------------------------------+
11. string PassWord(const string szArg)
12. {
13.     const string szCodePhrase = "TheQuickBrownFoxJumpsOverTheLazyDog";
14. 
15.     string  szPsw = "";
16.     uchar   pos;
17. 
18.     for (int c = 0; c < StringLen(szArg); c++)
19.     {
20.         pos = (uchar)(StringGetCharacter(szArg, c) % StringLen(szCodePhrase));
21.         szPsw = StringFormat("%s%c", szPsw, StringGetCharacter(szCodePhrase, pos));
22.     }
23. 
24.     return szPsw;
25. }
26. //+------------------------------------------------------------------+

Code 05

Wenn wir nun Code 05 und Code 04 vergleichen, können wir feststellen: „Es hat sich nichts geändert. Das wird nicht funktionieren. Das Ergebnis wird dem vorherigen sehr ähnlich sein." Aber ist das wahr? Finden wir es heraus. Wenn der Code 05 ausgeführt wird, sieht die Ausgabe wie folgt aus:

Abbildung 06

Wow! Es hat sich verändert, und zwar sehr verändert. Das ist etwas völlig anderes. Es sieht nicht so aus wie in Abbildung 05 dargestellt. Viele Menschen gehen davon aus, dass man ein Mathegenie oder ein sehr erfahrener Entwickler mit jahrelanger Praxis sein muss, um so etwas zu programmieren. Hier zeigt sich jedoch, dass man selbst mit einem grundlegenden Verständnis der Programmierung, kombiniert mit einer gesunden Portion Kreativität, sehr beeindruckende und manchmal sogar überraschende Ergebnisse erzielen kann. Wenn Sie nun finden, dass dieses Kennwort immer noch zu einfach ist, obwohl es ziemlich lang ist, können wir das ganz einfach ändern. Beachten Sie, dass der einzige Unterschied zwischen Code 04 und Code 05 die Zeile 13 ist. Keine andere Zeile wurde geändert. Da könnte man natürlich ins Grübeln kommen: Was wäre, wenn wir in Zeile 13 einige zusätzliche Symbole hinzufügen würden? Würde das Passwort dadurch sicherer werden? Versuchen wir auch das, liebe Leser. Aktualisieren wir also die Zeile 13 auf die nachfolgend gezeigte Version.

    const string szCodePhrase = ")0The!1quick@2brown#3fox$4jumps%5over^6the&7lazy*8dog(9";

Der Ausdruck ist:

Abbildung 07

Ist das nicht ein lustiges kleines Projekt, an dem wir gerade arbeiten? Und wir verwenden hier eine sehr einfache Programmierung. Aber wir können die Dinge noch ein wenig verfeinern, auch wenn dies einen etwas anderen Ansatz erfordert.

Dieses Mal werde ich etwas anders vorgehen, um Ihnen ein Detail näher zu bringen, das im letzten Artikel erwähnt wurde. Dort habe ich festgestellt, dass es den Typ String in C oder C++ nicht gibt. In MQL5 gibt es diesen Typ jedoch, insbesondere um nicht auf den in C und C++ verwendeten Programmieransatz angewiesen zu sein. In C und C++ ist eine Zeichenkette im Wesentlichen ein Array, das einen speziellen Wert enthält, der angibt, wo die Zeichenkette endet. Da MQL5 denselben Wert für denselben Zweck verwendet, können wir den passworterzeugenden Code so anpassen, dass er nicht mehr auf die Aufrufe der MQL5-Standardbibliothek angewiesen ist.

Jetzt möchte ich, dass Sie genau aufpassen. Wir sind dabei, in MQL5 etwas zu verwenden, das direkt aus C und C++ stammt. Deshalb habe ich gesagt, dass MQL5 in einer Art Mittelweg liegt, wie ich im vorigen Artikel erklärt habe. Vorerst möchte ich nur eine kurze Einführung in dieses Thema geben, das wir im nächsten Artikel eingehender behandeln werden.

Zeichenketten sind Arrays

Der Titel dieses Abschnitts sagt genau aus, was bei der Programmierung unter der Haube passiert. Ich weiß, dass dies zunächst verwirrend klingen mag. Aber im nächsten Artikel werden wir dieses Thema näher beleuchten. Ich möchte Ihnen dieses Konzept mit auf den Weg geben, damit Sie sich frühzeitig damit befassen können. Die Dinge werden sehr viel komplexer werden, und zwar schnell, wenn wir anfangen, dieses Thema eingehender zu erörtern.

Diesen Moment können wir nutzen, um den im vorherigen Abschnitt gezeigten Code zu aktualisieren und die Zeichenkette als Array zu behandeln. Das mag seltsam erscheinen, aber aus programmiertechnischer Sicht hat diese Vorgehensweise mehrere Vorteile.

Damit wird der Code 04, wie zuvor gesehen, zu der unten dargestellten Version:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string sz_Secret_Phrase = "Um pequeno jabuti xereta viu dez cegonhas felizes";
07. 
08.     Print("Result:\n", PassWord(sz_Secret_Phrase));
09. }
10. //+------------------------------------------------------------------+
11. string PassWord(const string szArg)
12. {
13.     const string szCodePhrase = "The quick brown fox jumps over the lazy dog";
14. 
15.     uchar   psw[],
16.             pos;
17. 
18.     ArrayResize(psw, StringLen(szArg));
19.     for (int c = 0; szArg[c]; c++)
20.     {
21.         pos = (uchar)(szArg[c] % StringLen(szCodePhrase));
22.         psw[c] = (uchar)szCodePhrase[pos];
23.     }
24.     return CharArrayToString(psw);
25. }
26. //+------------------------------------------------------------------+

Code 06

Wenn Sie Code 06 ausführen, ist die Ausgabe identisch mit der in Abbildung 05 gezeigten. Wenn Sie jedoch die Zeile 13, wie oben beschrieben, ändern, werden Sie feststellen, dass die Ergebnisse mit den vorherigen übereinstimmen. Dennoch bringt Code 06 einige Vorteile mit sich, da wir jetzt mit einem Array-basierten System arbeiten, anstatt direkt eine Zeichenkette zu verwenden. Die Vorteile dieses Ansatzes werden im nächsten Artikel näher erläutert, in dem ich näher darauf eingehe, wie man diese Art der Modellierung nutzen kann. Und ob Sie es glauben oder nicht, liebe Leserin, lieber Leser, dieser Code ist immer noch einfach genug, dass jeder gut unterrichtete Anfänger mit einer engagierten Lerngewohnheit ihn verstehen kann, ohne dass ich überhaupt erklären muss, wie er funktioniert.

Auf jeden Fall werde ich diesen Code im nächsten Artikel ausführlich erklären. Ich zeige es Ihnen jetzt nur, damit sich das Material nicht stapelt. Gehen Sie nicht davon aus, dass Sie es für später aufheben können, nur weil es einfach und leicht aussieht.

Abschließende Überlegungen

In diesem Artikel, der meiner Meinung nach sehr viel Spaß gemacht hat, haben wir etwas Praktisches geschaffen, mit einem echten Zweck, der über die Anwendung theoretischer Konzepte hinausgeht. Ich weiß, dass einige der von uns angesprochenen Punkte zunächst abschreckend wirken. Aber das sollte kein Grund sein, aufzugeben. Ganz im Gegenteil. Was ich hier zeigen möchte, ist, dass auch ein Programmieranfänger, ausgestattet mit Kreativität und ein wenig Cleverness, Textdaten erstellen und manipulieren kann, um etwas zu schaffen, von dem viele glauben, dass es jahrelange Programmiererfahrung erfordert.

Ich glaube, dass die Anwendung dieser Konzepte mit nur grundlegenden Kenntnissen - denn alles hier basiert auf dem, was in früheren Artikeln behandelt wurde - Sie engagierter und weniger passiv machen wird. Es ist nun hoffentlich klar, dass der bisher gelernte Stoff nützlich und relevant ist. Das war's. Viel Spaß beim Erkunden der beigefügten Dateien. Wir sehen uns im nächsten Artikel, in dem wir über ARRAYS sprechen werden.