Verstehen der MQL5 Objektorientierte Programmierung (OOP)

Einführung

In diesem Artikel werden wir eines der wichtigsten Themen in der Programmierung teilen, die zu einer reibungslosen und einfachen Kodierung führen und uns als Entwickler oder Programmierer hilft, das Konzept von „DRY“ anzuwenden, die Abkürzung von „Do Not Repeat Yourself“ oder „keine Wiederholungen“ ist. Zusätzlich zur Erhöhung der Sicherheit der erstellten Software und anderer Funktionen. Wir werden über objektorientierte Programmierung (OOP) sprechen und darüber, wie wir dieses Konzept nutzen und in MQL5 (MetaQuotes Language) kodieren können, indem wir zuerst die Grundlagen von OOP verstehen und dann verstehen, wie man es in MQL5 nutzt, indem wir einige Anwendungen sehen.

Daher werden wir dieses interessante und wichtige Thema anhand der folgenden drei Punkte behandeln:

• Was ist die OOP
• OOP in MQL5
• OOP-Anwendungen
• Schlussfolgerung

Das Hauptziel dieses Artikels ist es, die Grundlagen der objektorientierten Programmierung (OOP) im Allgemeinen zu verstehen und wie sie bei der Softwareerstellung nützlich sein kann. Von dort aus werden wir lernen, wie wir diesen Ansatz in MQL5 anwenden können, was uns helfen kann, effektivere und sicherere Software zu erstellen, indem wir diesen unglaublichen Ansatz anwenden.

Es wird für jeden sehr nützlich sein, mehr über diesen OOP-Ansatz zu erfahren. Es gibt sehr wichtige und informative Ressourcen über diesen Ansatz im Allgemeinen, zumal er auch in anderen Programmiersprachen wie C++, Java, Python und anderen anwendbar ist. In der MQL5-Sprache gibt es eine sehr wichtige Ressource nicht nur in das Thema des Artikels, sondern jedes einzelne Thema in der MQL5-Sprache, die die MQL5-Dokumentation ist, können Sie das Thema der OOP durch den Link von MQL5 OOP-Dokumentation überprüfen.

Haftungsausschluss: Alle Informationen werden in der vorliegenden Form nur zu Informationszwecken bereitgestellt und sind nicht für Handelszwecke oder als Ratschläge gedacht. Die Informationen garantieren keinen Erfolg. Wenn Sie sich dafür entscheiden, diese Materialien auf einem Ihrer Handelskonten zu verwenden, tun Sie dies auf eigenes Risiko und Sie sind allein verantwortlich.

Was ist die OOP

In diesem Thema werden wir die Grundlagen von OOP im Allgemeinen kennenlernen, also lassen Sie uns mit diesem interessanten Thema beginnen, indem wir OOP definieren. OOP ist die Abkürzung für Object-Oriented Programming (objektorientierte Programmierung) und ist ein Paradigma der Computerprogrammierung. Es hilft dabei, wiederverwendbare Software ohne doppelte Arbeit und doppelten Code zu erstellen und zu entwickeln, und das hilft uns, das DRY-Konzept (Do not Repeat Yourself) anzuwenden.

Wie wir sehen werden, hilft uns die OOP, der Natur der Welt näher zu kommen, denn alles um uns herum besteht aus Objekten, und jedes hat seine eigene Natur und sein eigenes Verhalten, und das ist es, was wir mit unseren Daten in der Software tun können. Wenn wir mehr in die OOP eintauchen wollen, müssen wir wissen, dass wir es mit Objekten und Klassen zu tun haben, wobei das Objekt eine Instanz einer Klasse ist und die Klasse eine Vorlage für das Objekt darstellt. In der Vorlage, die die Klasse darstellt, legen wir das Verhalten dieses Objekts im Detail fest.

Grundlegende Konzepte von OOP:

Bei der Anwendung der OOP in der Software werden die folgenden Grundsätze angewandt.

1. Encapsulation (Verkapselung).
2. Abstraction. (Abstraktion).
3. Inheritance (Vererbung).
4. Polymorphism (Polymorphismus).

1. Verkapselung:

Verkapselung ist die Methode, die es ermöglicht, Funktionen und Daten in einer Klasse zu verknüpfen. Die Daten und Funktionen in der Klasse können privat sein, was nur innerhalb der Klasse zugänglich ist, oder sie können öffentlich sein, was außerhalb der Klasse zugänglich ist. Das Konzept der Kapselung hilft, die Komplexität der Klassenimplementierung zu verbergen, und gibt dem Entwickler die volle Kontrolle über seine Daten, indem es ihm hilft, alle Werte, die von anderen abhängen, konfliktfrei im Auge zu behalten.

Wir können also sagen, dass die Kapselung dazu beiträgt, unser System am Laufen zu halten und eine Menge möglicher Fehler zu vermeiden. Außerdem gibt sie dem Entwickler ein hohes Maß an Kontrolle und hilft beim Testen und Verarbeiten von Klassendaten, ohne den gesamten Code der Software zu beeinflussen oder zu ändern. Wie bereits erwähnt, hilft es auch, Fehler zu beheben und zu verhindern, dass die Kodierung kompliziert wird.

Die folgende Abbildung zeigt das Konzept der Kapselung:

2. Abstraktion:

Abstraktion ist die Methode, unnötige Details zu verbergen und nur die wesentlichen Details zu präsentieren. Sie ist breiter angelegt als das Konzept der Kapselung, aber sie hilft, dasselbe Ziel zu erreichen, nämlich Daten zu schützen und Funktionen zu implementieren, ohne alles über den Implementierungsprozess aller Klassen zu wissen, sondern nur zu wissen, was ich tun muss, damit die Implementierung durchgeführt werden kann.

Zu diesem Zweck müssen wir zwei wichtige Methoden berücksichtigen: die Schnittstelle und die Implementierung. Die Schnittstelle ist die Methode, die es den Klassen ermöglicht, miteinander zu interagieren und umzugehen, aber die Implementierung ist die Methode, die alle Details des Codes oder die Logik der Klassen enthält. Abstraktion hilft also dabei, die Sicherheit der Software zu erhöhen und hilft auch dabei, unseren Kodierungsprozess nicht zu wiederholen oder von Grund auf neu zu kodieren, sondern nur weitere Apps zu entwickeln und zu kodieren, die auf der bereits erstellten basieren.

3. Vererbung:

Vom Namen her bedeutet das Konzept der Vererbung, dass wir eine neue Klasse von einer alten ableiten und die neue die Eigenschaften der alten erbt. In diesem Fall wird die alte Klasse als Eltern- oder Superklasse bezeichnet und die neu abgeleitete als Kindklasse. Dieses Konzept hilft bei der Anwendung des DRY-Konzepts, liefert aber auch den Grundgedanken der Wiederverwendbarkeit.

4. Polymorphismus:

Poly in diesem Wort bedeutet viele oder mehrere und Morphismus so etwas wie Gestalt. Zusammen beschreibt es ein Konzept, das sich in mehreren Formen präsentieren kann. Also wenn zum Beispiel eine Summenmethode nicht nur zwei Summanden, a und b, sondern auch drei, a, b und c aufsummieren kann.

Einfach ausgedrückt, bedeutet Polymorphismus eine Schnittstelle und viele Methoden.

Wir können zusammenfassen. OOP ist eine Form der Computer-Programmierung, die auf der Organisation der Software durch Objekte beruht, mit einzigartigem Verhalten und Eigenschaften. Dies hilft besonders bei großen und komplexen Projekten, vor allem, wenn diese Software aktualisiert wird und manipuliert werden müssen.

OOP-Attribute und -Funktionen:

• Software, die den OOP-Ansatz verfolgt, enthält Klassen und Funktionen.
• Ein hohe Maß an Sicherheit, da die Daten durch die Anwendung von Kapselungs- und Abstraktionsprinzipien verborgen werden.
• Es erleichtert die Arbeit an komplexen Projekten, da der Code in kleine Codeblöcke unterteilt werden kann, was die Komplexität des Projekts verringern kann.
• Aktualisierungs- und Entwicklungsprozesse sind einfacher.
• Wiederverwendbarkeit von Code durch Anwendung des Vererbungsprinzips.
• Die Fähigkeit, viele Instanzen derselben Klasse ohne Konflikte zu erstellen.

Es gibt viele Programmiersprachen, die den OOP-Ansatz anwenden können. Die verbreitetsten sind zum Beispiel C++, C#, Python, Java, JavaScript, PHP und andere. Von diesen Sprachen, auf die wir den OOP-Ansatz anwenden können, ist MQL5 die Sprache, der wir uns im folgenden Thema zuwenden.

OOP in MQL5

In diesem Abschnitt werden wir über OOP in MQL5 lernen und wie wir sie nutzen können. Das gleiche, wie wir als Grundlagen der OOP, dass wir eine Klasse zu schaffen, wie eine Blaupause für ein Objekt und die Klasse selbst ist eine Sammlung oder enthält Variablen und Methoden, die das gleiche wie eine Funktion, aber es ist eine Methode in der Klasse, um eine bestimmte Reihe von Aufgaben durchzuführen genannt. Es ist auch gut, hier zu erwähnen, dass Variablen und Methoden oder Funktionen innerhalb der Klasse als Klassenmitglieder bezeichnet werden. Was wir hier sagen müssen, ist, dass es eine gute und allseits begrüßte Bemühung ist, dass das OOP-Konzepts in MQL5 verfügbar gemacht wurde, da es eine Menge Aufwand und Arbeit spart, wie wir zusätzlich zu der Qualität und Sicherheit erwähnt haben.

Wenn wir das OOP-Konzept in MQL5 anwenden wollen, müssen wir verstehen, wie wir das Folgende in MQL5 verwenden können:

• Klassen
• Zugriffsmodifikator
• Konstrukteure und Destrukteure
• Abgeleitete (untergeordnete) Klassen
• Virtuelle Funktionen
• Objekte

Klassen:

In MQL5 müssen wir, wenn wir eine Klasse als Blaupause eines Objekts erstellen wollen, diese Klasse im globalen Bereich deklarieren, genau wie die Funktionen. Wir können so eine Klasse erstellen, indem wir das Schlüsselwort class und danach einen eindeutigen Namen verwenden, gefolgt von in geschweiften Klammern gesetzten Variablen und Methoden. Das sind die Mitglieder dieser Klasse. Nach der schließenden, zweiten, geschweiften Klammer folgt unbedingt ein Semikolon, um die Deklaration der Klasse zu beenden. Übrigens, wir können diese Klassendeklaration im Programm oder in der Include-Datei platzieren.

Es folgt ein Beispiel für eine solche Klassendeklaration:

class Cobject
{
   int var1;       // variable1
   double var2;    // variable1
   void method1(); // Method or function1
};

Wie wir im vorherigen Beispiel sehen können, hat die Klasse drei Mitglieder, und zwar zwei Variablen und eine Methode oder Funktion.

Zugriffsmodifikatoren:

Mit diesen Zugriffsmodifikatoren können wir bestimmen, welche Variablen und Funktionen wir außerhalb der Klasse verwenden können, und wir haben drei Zugriffsschlüsselwörter, nämlich public (öffentlich), private (privat) und protected (geschützt).

• Public: repräsentiert Mitglieder, die außerhalb der Klasse verwendet werden können.
• Private: steht für Mitglieder, die nicht außerhalb der Klasse verwendet werden können, sondern nur innerhalb der Klasse für Funktionen zur Verfügung stehen. Die untergeordnete Klasse dieser Klasse wird diese privaten Mitglieder nicht erben.
• Protected: repräsentiert Mitglieder, die von untergeordneten Klassen geerbt werden, aber von Natur aus privat sind.

Wenn wir ein Beispiel dafür brauchen, können wir uns das folgende ansehen:

class Cobject
{
   private:
   int var1;       // variable1
   protected:
   double var2;    // variable1
   public:
   void method1(); // Method or function1
};

Wie wir im vorherigen Beispiel sehen können, haben wir drei Mitglieder in der Klasse mit zwei Variablen, von denen eine privat und die andere geschützt ist, und das dritte Mitglied ist öffentlich.

Konstruktoren und die Destruktoren:

Wenn wir Variablen in der Klasse initialisieren müssen, verwenden wir den Konstruktor. Er wird standardmäßig vom Compiler erstellt, wenn wir dies nicht tun, aber dieser Standardkonstruktor ist nicht sichtbar. Er muss auch öffentlich zugänglich sein. Andererseits ist der Destruktor eine automatisch aufgerufene Funktion, wenn ein Klassenobjekt zerstört wird. Der Destruktor ist durch eine Tilde (~) vor dem Namen des Konstruktoren gekennzeichnet. Unabhängig davon, ob der Destruktor vorhanden ist oder nicht, erfordern Zeichenketten, dynamische Arrays und Objekte unbedingt eine Deinitialisierung.

Im Folgenden wird ein Beispiel für einen Konstruktor gegeben:

class CPrices
  {
private:
   double               open;         // Open price
   double               high;         // High price
   double               low;          // Low price
   double               close;        // Close price
public:
   //--- Default constructor
                     CPrices(void);
   //--- Parametric constructor
                     CPrices(double o,double h,double l, double c);
  };

Abgeleitete (untergeordnete) Klassen:

Wie wir bereits gelernt haben, ist das Vererbungskonzept eines der wertvollsten und nützlichsten Merkmale der OOP, da wir eine Kindklasse aus einer Super- oder Elternklasse erstellen können und diese Kindklasse alle Mitglieder der Elternklasse mit Ausnahme der privaten Mitglieder erbt. Danach können wir neue Variablen und Funktionen für diese Kindklasse hinzufügen.

Wenn wir ein Beispiel benötigen, können wir das anhand des folgenden Beispiels sehen: Wenn wir eine übergeordnete Klasse für Preise haben, können wir eine untergeordnete Klasse für Tagespreise erstellen, wie im Folgenden beschrieben:

class CDailyPrices : public CPrices
{
public:
   double               open;          // Open price
   double               high;          // High price
   double               low;           // Low price
   double               close;         // Close price
};

Wie wir sehen können, lautet der Name der übergeordneten Klasse CPrices und CDailyPrices ist die untergeordnete oder abgeleitete Klasse. Jetzt finden wir, dass alle öffentlichen und geschützten Mitglieder von CPrices Teil der Klasse CDailyPrices sind und dass sie immer noch öffentlich sind.

Virtuelle Funktionen:

Wenn wir die Funktionsweise einer Methode oder Funktion in einer untergeordneten Klasse aktualisieren wollen, können wir dies tun, indem wir die (virtuelle) Funktion in der übergeordneten Klasse verwenden und dann die Funktion in der untergeordneten Klasse definieren. Zum Beispiel, wenn wir zwei verschiedene Versionen einer Funktion haben, die auf der Klasse basieren. Für die übergeordnete Klasse definieren wir die Funktion mit dem Schlüsselwort virtual:

class CVar
  {
public:
   virtual 
void varCal();
  };

Dann aktualisieren wir die gleiche Funktion in der abgeleiteten Kindklasse:

class CVar1 : public CVar
{
public:
 int varCal(int x, int y);
}; 

Objekte:

Objekte sind eindeutig gekennzeichnet, genauso wie wir es bei der Erstellung einer Variablen tun. Wir verwenden den Klassennamen als Typ vor dem Objektbezeichner. Wir können so viele Objekte erstellen, die zu unseren Klassen gehören, wie wir für das Projekt benötigen, wir müssen nur einen eindeutigen Bezeichner für alle verwenden. Nach der Deklaration des Objekts können wir auf jedes öffentliche Mitglied zugreifen, indem wir den Punkt-Operator „ . “ verwenden.

Ein Beispiel soll dies verdeutlichen: Wir erstellen eine Klasse mit einer Integer-Variablen für die Anzahl der Handelsgeschäfte (num_trades).

class CSystrades
{
public:
int num_trades;
};

Dann müssen wir ein Objekt erstellen, das zu dieser Klasse gehört und system1 genannt wird, indem wir dasselbe wie im Folgenden tun:

CSystrades system1;

Dann können wir dieses Objekt durch den (3)-Wert definieren, der dem folgenden entspricht:

system1.num_trades=3;

Jetzt haben wir verstanden, wie wir den OOP-Ansatz in MQL5 anwenden können, indem wir einige der wichtigsten Ideen dazu in diesem Thema gelernt haben.

OOP-Anwendungen

In diesem interessanten Teil werden wir einige einfache Anwendungen für die Anwendung des OOP-Ansatzes in unserer Software vorstellen, um zu verstehen, wie wir ihn nutzen können und wie nützlich er sein kann.

Die Anwendung priceClass (PreisKlasse):

In dieser einfachen Anwendung müssen wir die Preise von Multi- Zeitrahmen überprüfen, und in diesem Beispiel werden wir drei Zeitrahmen (täglich, wöchentlich und monatlich) präsentieren. Hier wollen wir auch alle Preise sehen (Open, High, Low, Close), wir wollen sie an einem Ort sehen, sagen wir in der Registerkarte Experts. Danach können wir dieses einfache Beispiel weiter ausbauen, um eine fortgeschrittenere Software zu implementieren.

Zunächst müssen wir die Klasse durch den folgenden Schritt deklarieren:

• Deklarieren der Klasse für Preise im globalen Bereich mit all ihren öffentlichen Mitgliedern durch das Schlüsselwort class.
• Verwenden des Schlüsselworts public.
• Erstellen von fünf Variablen (timeframe, open, high, low, and close).
• Erstellen einer void-Funktion, um alle Preisdaten zu drucken.

class CPrices
  {
public:
   string            timeFrame;
   double            open;
   double            high;
   double            low;
   double            close;
   void              pricesPrint()
     {
      Print(timeFrame," Prices = Open: ",open," - ","High: ",high,"-","Low: ",low,"-","Close: ",close);
     }
  };

Erstellen von Objekten aus der Klasse für Tages-, Wochen- und Monatspreise:

CPrices CDailyPrices;
CPrices CWeeklyPrices;
CPrices CMonthlyPrices;

In der Funktion OnInit werden wir für die drei Zeitrahmen Folgendes definieren:

• Festlegen des Zeitrahmens für die Zeichenkette.
• Festlegen des Eröffnungskurses mit der Funktion iOpen.
• Festlegen des Höchstpreises mit der Funktion iHigh.
• Festlegen des Niedrigpreises mit Hilfe der Funktion iLow.
• Festlegen des Schlusskurses mit der Funktion iClose.
• Aufrufen der Druckfunktion oder -methode.

int OnInit()
  {
//--- Daily time frame
   CDailyPrices.timeFrame="Daily";
   CDailyPrices.open=(iOpen(Symbol(),PERIOD_D1,1));
   CDailyPrices.high=(iHigh(Symbol(),PERIOD_D1,1));
   CDailyPrices.low=(iLow(Symbol(),PERIOD_D1,1));
   CDailyPrices.close=(iClose(Symbol(),PERIOD_D1,1));
   CDailyPrices.pricesPrint();

//--- Weekly time frame
   CWeeklyPrices.timeFrame="Weekly";
   CWeeklyPrices.open=(iOpen(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.high=(iHigh(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.low=(iLow(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.close=(iClose(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.pricesPrint();

//--- Monthly time frame
   CMonthlyPrices.timeFrame="Monthly";
   CMonthlyPrices.open=(iOpen(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.high=(iHigh(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.low=(iLow(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.close=(iClose(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.pricesPrint();
   return(INIT_SUCCEEDED);
  }

Danach können wir die Preise, die nach der Ausführung dieses Experten gedruckt wurden, auf der Registerkarte Experten in der Toolbox wie folgt finden:

Wie wir in der vorherigen Abbildung sehen können, haben drei gedruckte Zeilen:

• In der ersten Zeile werden die täglichen Eröffnungs-, Höchst-, Tiefst- und Schlusskurse ausgegeben,
• in der zweite die gleichen Preise der wöchentlichen Daten und
• in der dritten wieder das Gleiche der Monatsdaten.

Die Anwendung indicatorClass:

Wir müssen eine Software erstellen, die in der Lage ist, die Werte von vier gleitenden Durchschnitten (einfache, exponentielle, geglättete und linear gewichtete Durchschnitte) auszugeben, indem wir den OOP-Ansatz verwenden. Es folgen einfache Schritte zur Erstellung dieser Art von Software:

Wir deklarieren die Klasse CiMA mit dem Schlüsselwort class und erstellen öffentliche Mitglieder dieser Klasse. Es handelt sich dabei um vier allgemeine Variablen: MAType für den Typ des gleitenden Durchschnitts, MAArray für das Array des gleitenden Durchschnitts, MAHandle für das Handle der Typen und MAValue für den Wert eines jeden gleitenden Durchschnitts. Erstellen wir die void-Methode valuePrint und den Hauptteil der Funktion, um den Wert jedes gleitenden Durchschnittstyps auszugeben.

class CiMA
  {
public:
   string            MAType;
   double            MAArray[];
   int               MAHandle;
   double            MAValue;
   void              valuePrint()
     {
      Print(MAType," Current Value: ",MAValue);
     };
  };

Folgenden Objekte erstellen wir für jeden gleitenden Durchschnitt der Klasse:

• Der Name des Durchschnitts
• Das Handle des Durchschnitts
• Die Zeitreihe (array) des Durchschnitts

//--- SMA
CiMA CSma;
CiMA CSmaHandle;
CiMA CSmaArray;

//--- EMA
CiMA CEma;
CiMA CEmaHandle;
CiMA CEmaArray;

//--- SMMA
CiMA CSmma;
CiMA CSmmaHandle;
CiMA CSmmaArray;

//--- LWMA
CiMA CLwma;
CiMA CLwmaHandle;
CiMA CLwmaArray;

Innerhalb der OnInit-Funktion führen wir die folgenden Schritte für jeden gleitenden Durchschnittstyp aus:

• Definieren des Namens des Durchschnitts.
• Definieren des Handles des Durchschnitts.
• Wir setzen das Flaf AS_SERIES für das Array mit der Funktion ArraySetAsSeries.
• Abrufen der Daten des Puffers für den Durchschnittsindikator mit Hilfe der Funktion CopyBuffer.
• Ermitteln des Durchschnittswerts und normalisieren mit der Funktion NormalizeDouble.
• Aufrufen der erstellten Methode oder Funktion Print

int OnInit()
  {
   //--- SMA
   CSma.MAType="Simple MA";
   CSmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_SMA,PRICE_CLOSE);
   ArraySetAsSeries(CSmaArray.MAArray,true);
   CopyBuffer(CSmaHandle.MAHandle,0,0,3,CSmaArray.MAArray);
   CSma.MAValue=NormalizeDouble(CSmaArray.MAArray[1],_Digits);
   CSma.valuePrint();

   //--- EMA
   CEma.MAType="Exponential MA";
   CEmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_EMA,PRICE_CLOSE);
   ArraySetAsSeries(CEmaArray.MAArray,true);
   CopyBuffer(CEmaHandle.MAHandle,0,0,3,CEmaArray.MAArray);
   CEma.MAValue=NormalizeDouble(CEmaArray.MAArray[1],_Digits);
   CEma.valuePrint();

   //--- SMMA
   CSmma.MAType="Smoothed MA";
   CSmmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_SMMA,PRICE_CLOSE);
   ArraySetAsSeries(CSmmaArray.MAArray,true);
   CopyBuffer(CSmmaHandle.MAHandle,0,0,3,CSmmaArray.MAArray);
   CSmma.MAValue=NormalizeDouble(CSmmaArray.MAArray[1],_Digits);
   CSmma.valuePrint();

   //--- LWMA
   CLwma.MAType="Linear-weighted MA";
   CLwmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_LWMA,PRICE_CLOSE);
   ArraySetAsSeries(CLwmaArray.MAArray,true);
   CopyBuffer(CLwmaHandle.MAHandle,0,0,3,CLwmaArray.MAArray);
   CLwma.MAValue=NormalizeDouble(CLwmaArray.MAArray[1],_Digits);
   CLwma.valuePrint();
   return(INIT_SUCCEEDED);
  }

Nach dem Kompilieren und Ausführen dieses Codes finden wir vier Zeilen für jeden Typ von gleitendem Durchschnitt, wobei jede Zeile den Wert des Durchschnitts wie folgt ausgibt:

Wie ich bereits erwähnt habe, können wir diese Anwendungen entwickeln, um kompliziertere und fortgeschrittene Aufgaben zu implementieren, aber hier ist das Ziel, die Grundlagen der objektorientierten Programmierung (OOP) zu lernen und zu verstehen und wie wir diesen Ansatz in MQL5 anwenden können, weil es viele Funktionen gibt, die wir erstellen können, wenn wir diesen nützlichen Ansatz anwenden.

Schlussfolgerung

In diesem Artikel haben wir die Grundlagen eines sehr wichtigen Themas und Ansatzes in der Programmierung im Allgemeinen gelernt. Wir haben gelernt, wie nützlich dieser Ansatz bei der Entwicklung unserer Software ist, indem wir erfahren haben, wie er uns hilft, sichere und hochgradig gesicherte Software zu erstellen, wie er hilft, die Komplexität der Software zu verringern, indem er den Code in kleine Codeblöcke aufteilt, was den Codierungsprozess vereinfacht, und wie er hilft, viele Instanzen derselben Klasse zu erstellen, ohne dass es zu Konflikten kommt, selbst wenn sie ein unterschiedliches Verhalten aufweisen.

Wir lernten auch, wie man diesen wichtigen Ansatz in MQL5 anwendet, um all diese unglaublichen Funktionen zu erhalten. Dann lernten wir einige einfache Anwendungen, die durch Anwendung des OOP-Ansatzes in MQL5 erstellt werden können, um im MetaTrader 5 verwendet zu werden.

Ich hoffe, dass dieser Artikel für Sie nützlich war und Ihnen geholfen hat, ein sehr wichtiges und entscheidendes Thema in der MQL5-Programmierung zu lernen, da er Ihnen mehr Einblicke darüber geben kann, wie viele Ideen bei der Codierung nach Anwendung dieses OOP-Ansatzes einfach sein können.

Wenn Ihnen dieser Artikel gefallen hat und Sie mehr darüber erfahren möchten, wie Sie Handelssysteme in MQL5 erstellen können, die im MetaTrader 5 auf der Grundlage der beliebtesten technischen Indikatoren verwendet werden können, und wie Sie einen nutzerdefinierten technischen Indikator erstellen und ihn in Ihrem Expert Advisor verwenden können, können Sie meine anderen Artikel zu diesen Themen durch die Veröffentlichung auf meinem Profil lesen, und ich hoffe, dass Sie sie auch nützlich finden.