Von der Grundstufe bis zur Mittelstufe: Variablen (I)

Einführung

Die hier vorgestellten Materialien sind ausschließlich für didaktische Zwecke bestimmt. Die Anwendung sollte nur zum Erlernen und Beherrschen der vorgestellten Konzepte verwendet werden.

Der Zweck dieses Artikels ist es, einige Konzepte und die Verwendung von MQL5 für verschiedene Aktivitäten zu erläutern. Es ist nicht nur auf die Erstellung von Indikatoren, Skripten oder Expert Advisors ausgerichtet. Das Hauptziel ist dabei die Vermittlung von Wissen.

Viele von Ihnen kennen mich bereits aus anderen Artikeln. Da sich diese Artikel jedoch an Programmierer mit einiger Erfahrung richten und viele ihr Interesse bekundet haben, mehr über dieses Thema zu erfahren, dachte ich, es wäre interessant, eine weitere Serie mit einigen grundlegenden Erklärungen zu erstellen. Das bedeutet nicht, dass wir Themen besprechen, die jeder schon kennt und die die Artikel langweilig und sinnlos machen. Im Gegenteil, ich werde mich bemühen, Materialien bereitzustellen, die wirklich interessant und spannend sind. Da aber bereits viele Artikel in der anderen Richtung auf ihre Veröffentlichung warten, habe ich nun die Gelegenheit, mein Wissen in dieser neuen Serie zu teilen. Wir werden Fragen im Zusammenhang mit dem Übergang von der Grundstufe zu dem, was ich als Mittelstufe betrachte, behandeln. Nichtsdestotrotz werden wir Konzepte innerhalb von MQL5 lernen, und einige von ihnen werden für diejenigen nützlich sein, die andere Programmiersprachen lernen wollen.

Wir beginnen diesen Artikel mit dem grundlegendsten und fundamentalsten Teil der Programmierung im Allgemeinen. Heute werden wir über Variablen sprechen. Da ich die Dinge gerne klar trennen möchte, beginnen wir den Artikel mit einem neuen Thema.

Variablen. Grundlagen der Programmierung

Viele Menschen glauben fälschlicherweise, dass Computerprogramme auf Funktionen und Methoden aufgebaut sind. Doch diese Annahme ist falsch. Computerprogramme sind meist auf Variablen aufgebaut. Kein Programm wird für einen anderen Zweck erstellt oder bereitgestellt. Das Ziel ist immer, die Variable bekannt und nutzbar zu machen.

Natürlich mag dieser Gedanke den Lesern seltsam vorkommen, vor allem, wenn sich alle Kurse und Bücher auf Funktionen und Methoden konzentrieren und damit implizieren, dass dies die Grundprinzipien der Programmierung sind. Ich bin jedoch nicht hier, um Kontroversen oder Meinungsverschiedenheiten zu verursachen. Ich bin hier, um meinen Beitrag zu leisten. Die als Funktionen und Methoden bezeichneten Begriffe sind zwar sehr wichtig, aber sie sind nichts anderes als eine Art berechnete Variable. Dies wird in den nächsten Artikeln noch deutlicher werden.

In diesem ersten Artikel möchte ich Ihnen das Konzept der Variablen vorstellen. Und ja, es gibt Unterschiede zwischen den Variablen. Das Wissen um die einzelnen Typen und deren optimale Verwendung macht den Unterschied zwischen einem gut geschriebenen Programm und einem einfachen Programm, das eine bestimmte Aufgabe erfüllt.

Zunächst einmal gibt es zwei verschiedene Arten von Variablen: solche, die ihren Wert ändern können, und solche, die ihn nicht ändern können. Im zweiten Fall werden solche Variablen als Konstanten bezeichnet. Da jedoch Computerprogramme, die im Nutzermodus laufen, immer im RAM vorhanden sind, ist das Wort „Konstante“ nicht so passend. Der Grund dafür ist, dass der Wert im Arbeitsspeicher liegt und daher auf irgendeine Weise verändert werden kann. Wer hat nicht schon einen CRACK ausprobiert, um Einschränkungen zu umgehen? In vielen Fällen wirkt der CRACK direkt in einem Teil der ausführbaren Datei, entweder im RAM oder auf der Festplatte.

Wenn der Eingriff auf der Festplatte erfolgt, wirkt der CRACK direkt auf die Konstanten. Das liegt daran, dass sich die Werte auf der Festplatte im Laufe der Zeit nicht ändern. Sie bleiben in der Regel unverändert. Ein CRACK wirkt also tatsächlich auf einen Wert, der nur scheinbar konstant ist. Sie ist aber gerade deshalb variabel, weil ein CRACK sie verändern kann. Beim Arbeitsspeicher können jedoch einige Teile als Konstanten betrachtet werden, und der Versuch, diese Werte zu ändern, wird als Fehler angesehen. Der Prozessor muss das Betriebssystem benachrichtigen, damit es die notwendigen Maßnahmen ergreift. Zunächst einmal ist zu beachten, dass Variablen konstant sein können oder nicht. Wenn sich die Werte im RAM befinden, kann unsere Anwendung bestimmen, was konstant und was variabel sein soll. In jedem anderen Szenario sollten Variablen niemals als Konstanten behandelt werden.

Nach dieser kleinen Klarstellung können wir zum nächsten Schritt übergehen, bei dem das gleiche Konzept in die Praxis umgesetzt wird. Beginnen wir Schritt für Schritt. Einige Konzepte sind nur schwer voneinander zu trennen, sodass das Ganze zunächst recht kompliziert erscheinen mag. Haben Sie Geduld, liebe Leserin, lieber Leser. Schon bald werden Sie sich selbstbewusster fühlen und es wird Ihnen leichter fallen, verschiedene Dinge zu tun. Sehen wir uns das Ganze Stück für Stück an, beginnend mit dem, was unten gezeigt wird.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int     value1;
07.     char    value2;
08.     long    value3;
09. 
10.     value1 = 10;
11.     value2 = 5;
12.     Print("Result: ", value1 + value2 + value3);
13. }
14. //+------------------------------------------------------------------+

Code 01

Dieser Code ist sehr einfach und grundlegend. Hier haben wir drei Variablendeklarationen in den Zeilen 06, 07 und 08. Es gibt noch keinen Grund, sich über Typen Gedanken zu machen. Wir werden in einem anderen Artikel ausführlicher darüber sprechen. Achten Sie vorerst nur auf das, was erklärt wird. Obwohl wir hier drei Variablen deklariert haben, sind zwei von ihnen eigentlich temporäre Konstanten, und die andere wird nicht referenziert oder, wenn wir den richtigen Begriff verwenden, initialisiert. Oft denkt man, dass dieser Code ein bestimmtes Ergebnis hervorbringen wird. Wenn Sie jedoch nicht verstehen, wie die verschiedenen Denkweisen funktionieren, oder sie ignorieren, kann Ihre gesamte Arbeit gefährdet sein.

Um dies zu verstehen, sehen wir uns die Ausgaben des Compilers an. Wenn Sie MetaEditor verwenden, sieht das Ergebnis wie in Abbildung 01 aus.

Abbildung 01:

In meinem Fall verwende ich ein anderes Tool, um Code zu bearbeiten, aber es verwendet auch den MetaTrader 5 Compiler, um die Anwendungen zu erstellen. Die Ausgabe lautet wie folgt:

Abbildung 02

Beachten Sie, dass der Compiler in beiden Fällen eine Warnung ausgibt, und wir sollten vorsichtig sein, wenn eine Warnung erscheint. Denn oft weist eine Warnung darauf hin, dass sich unsere Anwendung auf unerwartete Weise verhält. Wenn wir einen Punkt in Bezug auf die Compiler-Ausgabe anzeigen müssen, werden wir dies nach dem in Abbildung 02 gezeigten Modell tun. Das Ergebnis ist jedoch sehr ähnlich zu den Meldungen, die wir bei der Verwendung von MetaEditor sehen würden. Lesen Sie also bitte aufmerksam, damit Sie alle weiteren Artikel verfolgen können.

Nehmen wir nun an, wir hätten diese Compilerwarnung ignoriert. Einige von ihnen können ignoriert werden, andere nicht. Und wir haben beschlossen, diese Anwendung, die bereits in MetaTrader 5 kompiliert wurde, auf den Markt zu bringen. Welche Art von Ergebnissen erwarten Sie? Wahrscheinlich erwarten Sie den Wert 15, weil wir in Zeile 10 sagen, dass die Variable value1 gleich 10 ist, und in Zeile 11 sagen wir, dass die Variable value2 gleich 5 ist. Wenn also Zeile 12 ausgeführt wird, ist das erwartete Ergebnis die Summe dieser beiden Werte, richtig? Sehen wir es uns an. Das Ergebnis ist unten dargestellt.

Abbildung 03

Was ist hier also passiert? Ist das wirklich möglich?! Ja, lieber Leser, das ist möglich. Davon können Sie sich selbst überzeugen. Aber Ihre Verwunderung ist durchaus berechtigt, denn Sie haben eindeutig erwartet, dass der gedruckte Wert 15 beträgt. Warum wird Null erzeugt? Der Grund liegt in der Variable value3. Da sie an der Berechnung teilnimmt und NICHT ordnungsgemäß initialisiert wurde, kann sie jeden beliebigen Wert enthalten. Je nach diesem Wert, den wir in der Programmierung als „Junk“ bezeichnen, wird das Endergebnis nicht korrekt sein.

In diesem Fall haben wir zwei Alternativen. Die erste besteht darin, value3 korrekt zu initialisieren. Die zweite besteht darin, den value3 aus der in Zeile 12 durchgeführten Berechnung zu entfernen. Da unser Ziel in diesem Stadium ist, ein Ergebnis gleich 15 zu erhalten, wählen wir die zweite Option. Im gleichen Code 01 ändern wir also Zeile 12 wie unten gezeigt.

Print("Result: ", value1 + value2);

Wenn Sie in diesem Fall versuchen, den Code zu kompilieren, wird der Compiler die folgende Warnung ausgeben.

Abbildung 04

Beachten Sie, dass sich die Warnung von der zuvor genannten unterscheidet. Wir analysieren sie und kommen zu dem Schluss, dass sie in diesem speziellen Fall ignoriert werden kann. Wir starten die Anwendung in MetaTrader 5 und erhalten das unten dargestellte Ergebnis.

Abbildung 05

Es hat geklappt! Wir haben genau das erreicht, was wir erwartet haben. Lassen Sie uns nun zum Quellcode 01 zurückkehren, um einige grundlegende Konzepte zu verstehen. Wie bereits erwähnt, können und sollten die Variablen value1 und value2 als temporäre Konstanten betrachtet werden. Warum? Der Grund dafür ist, dass sie ihren Wert während des gesamten Codes NICHT ändern, sondern immer den gleichen Wert haben. Es gibt jedoch ein Problem, und hier wird es ein wenig interessant.

Obwohl value1 und value2, sowie value3 Variablen sind, können wir als Programmierer dies ändern. Auf diese Weise ist gewährleistet, dass sich der dieser Variablen zugewiesene Wert NICHT ändert, unabhängig davon, welche Fehler wir beim Schreiben des Codes machen. Viele erfahrene Programmierer, die mit komplexerem und komplizierterem Code arbeiten, bevorzugen Sprachen, die diese Art von Kontrolle ermöglichen. In solchen Fällen können Sie als Programmierer sagen: „Hör zu, Compiler, diese Variable sollte nicht als Variable behandelt werden, ich möchte, dass sie eine Konstante ist.“ Und der Compiler hilft Ihnen dabei, dass diese Variable als Konstante gespeichert wird. Um diese Kontrolle in MQL5 zu erreichen, verwenden wir ein reserviertes Wort. So kann ein Code, der das gleiche Ergebnis wie der vorherige liefert, auf andere Weise geschrieben werden. Doch bevor wir uns mit der Praxis befassen, wollen wir uns etwas anderes ansehen. Daraus ergibt sich der folgende Code.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int   value1;
07.     char        value2;
08. 
09.     value1 = 10;
10.     value2 = 5;
11.     Print("Result: ", value1 + value2);
12. }
13. //+------------------------------------------------------------------+

Code 02

Wenn Sie versuchen, Code 02 zu kompilieren, lässt der Compiler dies aufgrund der unten aufgeführten Fehler nicht zu.

Abbildung 06

In diesem Fall sind wir auf zwei Fehler gestoßen: einen in der sechsten und einen in der neunten Zeile. Kommen wir nun zu den Fehlern, denn das Wichtigste ist nicht nur, sie zu korrigieren, sondern zu verstehen, was sie uns sagen. Dies liegt daran, dass ein Fehler nicht immer ein Fehler an sich ist. Oft handelt es sich dabei um eine einfache Compiler-Warnung, die darauf hinweist, dass Sie versuchen, etwas zu tun, was Sie nicht tun sollten. Dies ist bei dem Fehler in der neunten Zeile genau der Fall.

Bitte achten Sie auf diesen Hinweis, da er Ihnen bei der MQL5-Programmierung sehr helfen kann. Wenn wir eine Variable als Konstante definieren, wird jeder Versuch, ihren Wert während der Ausführung des Codes zu ändern, als schwerwiegender Fehler gewertet. Wir haben unsere App noch nicht auf den Markt gebracht. Trotzdem warnt uns der MQL5-Compiler bereits vor der Möglichkeit eines schwerwiegenden Fehlers während der Ausführung. Aus diesem Grund ist es nicht möglich, den 02-Code zu kompilieren. Dies geschieht, weil wir dem Compiler mitgeteilt haben, dass die Variable value1 KEINE Variable, sondern eine KONSTANTE ist. Zu diesem Zweck wird das Wort „const“ vor dem Operator verwendet, wie in der sechsten Zeile von Code 02 gezeigt. Viele weniger erfahrene Programmierer würden es vorziehen, das Wort „const“ aus der Erklärung in Zeile 6 zu entfernen. Dies ist kein Fehler, aber es hebt die Hilfe des Compilers auf, der verhindert, dass die Variable value1 als Konstante behandelt wird. Dies wiederum kann zu anderen Problemen in der Anwendung führen, z. B. zur Erzeugung falscher Werte zu bestimmten Zeiten, ohne dass man versteht, warum sich der Code nicht wie erwartet verhält.

Es gibt jedoch noch ein weiteres Problem, das den Fehler in der sechsten Zeile verursacht, wie in Abbildung 06 zu sehen ist. Dieses Problem führte dazu, dass Code 01 zur Laufzeit einen falschen Wert erzeugte, wenn die Variable value3 in der Berechnung von Zeile 12 verwendet wurde, die auf Code 01 verwies.

Das Problem liegt genau in der Initialisierung der Werte. Einige Sprachen initialisieren die Werte von Variablen, in der Regel standardmäßig auf Null. In diesem Fall müssen die Compiler-Entwickler jedoch darauf achten, dass die als Konstanten behandelten Variablen keinen explizit definierten Wert haben. Die willkürliche und implizite Zuweisung von Null an eine nicht initialisierte Variable kann sich nachteilig auf die endgültige Anwendung auswirken. Das liegt genau an dem in Code 02 gezeigten Detail: Würde der Compiler jeder nicht initialisierten Variablen automatisch den Wert Null zuweisen, wäre das Ergebnis der Operation in Zeile 11 völlig falsch. Und Sie als Programmierer würden viel Zeit darauf verwenden, herauszufinden, warum. Ein Fehler ist also nicht immer ein Fehler. Auch Compiler-Warnungen müssen nicht immer behoben werden. In manchen Fällen können wir einige der von ihnen angegebenen Informationen ignorieren.

Okay, jetzt, da wir das geklärt haben, wie sollten wir Code 02 schreiben, damit er kompiliert werden kann? In Anbetracht der Tatsache, dass wir wirklich wollen, dass es so ist, sollte der Code wie unten gezeigt geändert werden.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int   value1 = 10;
07.     char        value2;
08. 
09.     value2 = 5;
10.     Print("Result: ", value1 + value2);
11. }
12. //+------------------------------------------------------------------+

Code 03

Jetzt ist alles richtig. Dieser Code 03 wird kompiliert. Das Ergebnis ist in Abbildung 05 zu sehen. Aber vielleicht haben Sie Zweifel: Warum programmieren Sie das genau so, wie es der Autor zeigt? Wäre es nicht einfacher, etwas anderes zu verwenden, wie den folgenden Code?

1. #property copyright "Daniel Jose"
2. //+------------------------------------------------------------------+
3. void OnStart(void)
4. {
5.     Print("Result: ", 10 + 5);
6. }
7. //+------------------------------------------------------------------+

Code 04

Nun, in manchen Fällen ist es tatsächlich am einfachsten, etwas wie Code 04 zu programmieren, da wir es ausschließlich mit Konstanten zu tun haben. Dieser Ansatz ist jedoch nicht immer wünschenswert. Dies geschieht, weil numerische Konstanten „kalt“ sind und keine Informationen darüber enthalten, warum sie existieren. Wenn Sie sich Code 04 ansehen, können Sie den Grund für die Verwendung der Werte 10 und 5 nennen? Vielleicht führen wir eine Faktorisierung durch, um ein zunächst unbekanntes Ergebnis zu entdecken. Wenn dies der Fall wäre, würden wir eine andere Art von Variablen verwenden, die wir in einem anderen Artikel ausführlich behandeln werden. Wäre dies jedoch nicht der Fall, würden wir uns irgendwann fragen, warum eine solche Berechnung durchgeführt wird, und wir könnten am Ende Schwierigkeiten haben, unseren eigenen Code zu verstehen.

Aus diesem Grund nutzen viele Programmierer bestimmte Ressourcen der von ihnen verwendeten Programmiersprache. In diesem Fall (wenn wir gerade erst anfangen, über dieses Thema zu sprechen und daher erklären, wie man effizienter programmiert) ist die Verwendung von Variablen die beste Wahl. Das liegt daran, dass wir einer Variablen einen passenden Namen geben können und auch nach langer Zeit noch den Zweck dieses Wertes verstehen können, selbst wenn die Variable als Konstante implementiert wurde.

Ich glaube, der erste Punkt ist richtig erklärt worden. Der Leser kann nun verstehen, warum wir in manchen Fällen sagen, dass eine Variable konstant ist und in anderen nicht, und auch, was eine solche Erklärung mit unseren Lieblingsvariablen macht. Wir werden noch Gelegenheit haben, über dieses Thema zu sprechen, sodass wir jetzt zu einem anderen Aspekt übergehen können, ohne über die Grundbegriffe der Variablen hinauszugehen.

Lebenszeit und Sichtbarkeit

Eine der Fragen, die selbst erfahrene Programmierer oft vor ein Rätsel stellt, ist die Lebensdauer von Variablen und ihr Sichtbarkeitsbereich. Obwohl diese beiden Fragen unterschiedlich zu sein scheinen, können sie zusammen betrachtet werden, da Lebenszeit und Sichtbarkeit in gewisser Weise miteinander verbunden sind. Die Sichtbarkeit ist ein viel breiteres Thema, das wir im Laufe der Zeit in anderen Artikeln ausführlicher behandeln werden, da es Fragen der Sichtbarkeit gibt, die einen großen Einfluss darauf haben, wie eine Anwendung gestaltet sein sollte. Wir werden das zu gegebener Zeit in Ordnung bringen.

Wir wollen uns zunächst auf das Wichtigste konzentrieren: wann eine Variable „geboren“ wird, wo sie „stirbt“ und ob ihr „Tod“ verhindert werden kann.

Um die Dinge nicht zu verkomplizieren, sollten wir einige Überlegungen anstellen. Die erste und einfachste davon ist die folgende:

Eine Variable wird in dem Moment geboren, in dem sie deklariert wird.

Diese Aussage scheint offensichtlich zu sein, aber die Dinge werden ein wenig verwirrender, wenn man sie aus der Perspektive der variablen Sichtbarkeit betrachtet. Bevor wir uns mit diesem Thema befassen, wollen wir uns einen einfachen Fall ansehen. Hierfür verwenden wir den folgenden Code.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int value1 = 10;
07.     int value2;
08. 
09.     value2 = 5;
10.     {
11.         int value2;
12. 
13.         value2 = 8;
14. 
15.         Print("Result #01: ", value1 + value2);
16.     }
17.     Print("Result #02: ", value1 + value2);
18. }
19. //+------------------------------------------------------------------+

Code 05

Könnten Sie, bevor Sie Code 05 ausführen, beantworten, welcher Wert auf dem Terminal ausgegeben wird, wenn die Zeilen 15 und 17 ausgeführt werden? Wird dieser Code nicht einmal kompiliert? Bevor Sie anfangen zu zweifeln: Ja, dieser Code wird kompiliert und ausgeführt. Es gibt jedoch einen Punkt, den Sie verstehen müssen. Dies ist das erste von mehreren Dingen, die Sie im Laufe dieser Reise verstehen werden.

Wenn der Code 05 ausgeführt wird, sehen Sie das Ergebnis wie in der folgenden Abbildung dargestellt.

Abbildung 07

Jetzt frage ich Sie erneut: Können Sie diese Ergebnisse nachvollziehen? Dies ist nur eine kleine Demonstration dessen, was wir wirklich tun können. Viele Programmierer, selbst recht erfahrene, vermeiden es, Variablen im selben Codeblock denselben Namen zuzuweisen. Aber hier verwenden wir nicht einen, sondern zwei Codeblöcke. Aber wie ist das möglich? Haben wir hier in Code 05 wirklich zwei Codeblöcke? Liebe Leserinnen und Leser, ich habe noch nicht den Verstand verloren. Der Punkt ist, dass wir ein Thema nur gestreift haben, das ein anderes Mal deutlich werden wird. Aber in MQL5, wie auch in anderen C- und C++-ähnlichen Sprachen, beginnt jeder Codeblock mit einer öffnenden Klammer „{“ und endet mit einer schließenden Klammer „}“.

Alles, was zwischen diesen beiden Zeichen liegt, ist ein Codeblock und sollte auch als solcher betrachtet werden. Es gibt auch andere Möglichkeiten, einen Codeblock zu definieren, z. B. Schleifen. Diese Option, die Verwendung von Tasten, ist jedoch am einfachsten zu verstehen. In diesem Code beginnt der Block also in Zeile fünf und endet in Zeile achtzehn. Ein weiterer Block reicht von der zehnten bis zur sechzehnten Zeile. Wenn wir dies verstehen, können wir zwei Bereiche auf einmal abdecken.

Die erste ist die Tatsache, dass eine im Code deklarierte Variable ihr „Leben“ im Moment der Deklaration beginnt und ihr Leben in dem Moment endet, in dem der Block, zu dem sie gehört, aufhört zu existieren. Es kann eine Ausnahme geben, aber machen Sie sich darüber noch keine Gedanken. Versuchen Sie einfach, dieses einfache Konzept zu verstehen, mit dem wir es hier zu tun haben. Der zweite Punkt ist, dass alles, was außerhalb eines Blocks deklariert wird, innerhalb des Blocks als global betrachtet wird.

Dieser zweite Aspekt ist etwas schwieriger zu verstehen, aber wir wollen ihn Schritt für Schritt aufschlüsseln. Sehen wir uns zunächst an, warum der Code 05 die in Abbildung 07 gezeigte Ausgabe erzeugt. Aus den obigen Deklarationen können Sie ersehen, dass in den Zeilen 7 und 11 eine Variable mit demselben Namen deklariert wird. In den Zeilen 9 und 13 weisen wir einer Variable, die theoretisch dieselbe zu sein scheint, unterschiedliche Werte zu. Wenn Sie jedoch auf den Code achten, können Sie sehen, dass sie sich in verschiedenen Blöcken befinden: einer in einem Block und der andere in einem Block, der sich innerhalb des ersten Blocks befindet.

Einfach ausgedrückt: Der Block, in dem wir in Zeile 7 den Wert2 deklarieren, ist global. Daher ist der in Zeile 7 deklarierte Wert2 eine globale Variable. Die Variable value2, die in der elften Zeile deklariert wird, ist wiederum eine lokale Variable. Von außerhalb des Blocks betrachtet, ist die Variable in Zeile 11 lokal; innerhalb des Blocks, der in Zeile 10 beginnt, wird die in Zeile 11 deklarierte Variable in diesem Kontext jedoch als global betrachtet.

Ich weiß, dass dies verwirrend sein kann, halten wir also einen Moment inne und denken darüber nach. Das Verständnis dieses Konzepts ist äußerst wichtig, denn wir sind nicht gezwungen, ständig andere Namen zu verwenden. Der Compiler verlangt von uns, dass wir unterschiedliche Namen für Variablen im selben Block verwenden, aber wenn die Variablen in verschiedenen Blöcken sind, nimmt der Compiler an, dass es sich um unterschiedliche Variablen mit denselben Namen handelt.

Warum erhalten wir dann zwei unterschiedliche Werte im Endergebnis? Der Grund dafür ist einfach: Eine lokale Variable hat Vorrang vor einer globalen Variable, wenn beide den gleichen Namen haben, unabhängig vom Typ der Variablen. Wenn der Name identisch ist, verwendet der Compiler vorzugsweise die lokale Variable. Seien Sie jedoch vorsichtig, da andere Sprachen möglicherweise andere Techniken verwenden. Was wir hier gesehen haben, ist spezifisch für MQL5, da wir uns auf diese Sprache konzentriert haben.

Daher ist die folgende Tatsache leicht zu verstehen: Wenn wir in Zeile 13 sagen, dass value2 8 ist, wird der Wert, den value2 im globalen Bereich hat, der 5 ist und in Zeile 9 definiert wurde, nicht entfernt. Wenn wir also in Zeile 15 das Ergebnis der Addition von Wert1 und Wert2 ausgeben, erhalten wir im ersten Fall 18. Wenn Zeile 17 die gleiche Berechnung durchführt, ist das Ergebnis 15.

Wenn Sie jedoch versuchen, etwas Ähnliches mit dem folgenden Code zu tun:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int value1 = 10;
07.     int value2;
08. 
09.     value2 = 5;
10. 
11.         int value2;
12. 
13.         value2 = 8;
14. 
15.         Print("Result #01: ", value1 + value2);
16. 
17.     Print("Result #02: ", value1 + value2);
18. }
19. //+------------------------------------------------------------------+

Code 06

wird sich der Compiler beschweren und etwas ähnliches wie in Abbildung 08 unten erzeugen.

Abbildung 08

Der Grund dafür ist, dass Code 06 im Gegensatz zu Code 05 aus einem einzigen Block besteht, der in Zeile 5 beginnt und in Zeile 18 endet. Seien Sie also vorsichtig, wenn Sie Code schreiben oder versuchen zu verstehen, was ein anderer Programmierer geschrieben hat und warum Ihre Versuche, den Code zu ändern, fehlgeschlagen sind.

Es kann jedoch sein, dass Sie sich in einer etwas anderen Situation befinden. Ein Beispiel ist im nachstehenden Code zu sehen.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int value2;
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     const int value1 = 10;
09. 
10.     value2 = 5;
11. 
12.         int value2;
13. 
14.         value2 = 8;
15. 
16.         Print("Result #01: ", value1 + value2);
17. 
18.     Print("Result #02: ", value1 + value2);
19. }
20. //+------------------------------------------------------------------+

Code 07

In diesem Fall gibt der Compiler eine Meldung aus, die der in Abbildung 09 sehr ähnlich ist.

Abbildung 09

Welche Maßnahmen sollten in Bezug auf den Code 07 ergriffen werden, wenn wir ein ähnliches Ergebnis wie in Abbildung 07 erzielen wollen, wie in Abbildung 09 gezeigt? Liebe Leserinnen und Leser, der Moment ist gekommen, in dem alles viel komplizierter wird. Der Grund dafür ist, dass die Deklaration von value2 in Zeile 4 nur „stirbt“, wenn die Anwendung nicht mehr existiert oder nicht mehr läuft. Aus diesem Grund können Sie in solchen Fällen Variablen mit lokalem Geltungsbereich NICHT zusammen mit gleichnamigen Variablen mit globalem Geltungsbereich verwenden.

Im Allgemeinen sind globale Variablen oder Werte selbst ein Problem, das um jeden Preis vermieden werden sollte. Dies ist nicht immer möglich, aber wenn eine solche Situation eintritt oder es keine andere Möglichkeit gibt, sollten Sie verschiedene Namen für Variablen verwenden. Viele Programmierer, so auch ich, fügen oft ein Präfix oder Suffix hinzu, um globale Variablen, die für die gesamte Lebensdauer des Programms existieren, von lokalen oder sogar globalen Variablen zu unterscheiden, die zu einem bestimmten Block gehören.

Abschließende Überlegungen

Der erste Artikel ist zu Ende gegangen. In diesem Artikel habe ich versucht, Ihnen als Anfänger oder Gelegenheitsprogrammierer zu erklären, wie Sie mit MQL5 korrekter und produktiver arbeiten können. Der Zweck dieses Artikels ist es, einen Teil meiner Erfahrung als professioneller Programmierer mit Ihnen zu teilen, um Ihnen zu zeigen, wie Sie Ihre eigenen Codes einfach, effektiv und ohne unnötigen Ärger erstellen können.

Programmieren ist etwas Schönes und Unvergessliches. Mit der richtigen Herangehensweise und einem soliden und konsequenten Wissen werden Sie in der Zukunft mit Sicherheit gute Ergebnisse erzielen. Im nächsten Artikel werden wir uns also weiter mit den Variablen beschäftigen, da ich hier nur die Methodik vorgestellt habe, die wir in den folgenden Texten verwenden werden. Ich hoffe, es hat Ihnen gefallen. Wenn Sie sich mit einer komplexeren Materie, aber mit einer ähnlichen Methodik vertraut machen wollen, können Sie meine anderen Artikel lesen, die in dieser Gemeinschaft verfügbar sind, wenn auch unter einem anderen Profil veröffentlicht.