Unterstützen Sie Ihre Entwicklungsprojekte mit EX5-Bibliotheken
535
0
Einleitung
Der erfahrene Leser braucht keine Erklärung des Zwecks hinter dem Verbergen von Funktionen und Klassenimplementierungen in Bibliotheken. Jene von Ihnen, die aktiv nach neuen Ideen suchen, sollten wissen, dass Sie durch das Verbergen der Umsetzungsdetails von Klassen/Funktionen in einer .ex5-Datei Ihre Algorithmen mit anderen Entwicklern teilen, gemeinsame Projekte in die Wege leiten und sie im Internet bewerben können.
Und während das Team von MetaQuotes keine Mühen scheut, um die direkte Vererbung von ex5-Bibliotheksklassen zu ermöglichen, setzen wir sie jetzt schon um.
Inhaltsverzeichnis
1. Export und Import von Funktionen
2. Export der verborgenen Umsetzung einer Klasse
3. Initialisierung von Variablen in .ex5-Dateien
4. Vererbung von Export-Klassen
5. Veröffentlichen von ex5-Bibliotheken
1. Export und Import von Funktionen
Dies ist eine Grundlegende Methode hinter dem Export von Klassen. Drei wichtige Faktoren müssen berücksichtigt werden, damit andere Programme auf Ihre Funktionen zugreifen können:
- Die zu erstellende Datei muss die Erweiterung .mq5 (nicht .mqh) haben, damit sie zu einer .ex5-Datei kompiliert werden kann;
- Die Datei muss die Präprozessor-Direktive #property library enthalten;
- Hinter die Kopfzeilen der erforderlichen zu exportierenden Dateien muss das Schlüsselwort "export" gestellt werden
Example 1. Let us create a function to be used in other programs //--- library.mq5 #property library int libfunc (int a, int b) export { int c=a+b; Print("a+b="+string(с)); return(с); }
Nach dem Kompilieren dieser Datei erhalten Sie die Datei library.ex5, aus der die Funktion libfunc in anderen Programmen verwendet werden kann.
Der Prozess für den Import von Funktionen ist ebenfalls sehr einfach. Er wird mithilfe der Präprozessor-Direktive #import durchgeführt.
Example 2. We will use the export function libfunc() in our script //--- uses.mq5 #import "library.ex5" int libfunc(int a, int b); #import void OnStart() { libfunc(1, 2); }
Denken Sie daran, dass der Compiler nach .ex5-Dateien im Ordner MQL5\Libraries suchen wird. Wenn sich library.ex5 also nicht in diesem Ordner befindet, müssen Sie den relativen Pfad angeben.
Z. B.:
#import "..\Include\MyLib\library.ex5" // the file is located in the MQL5\Include\MyLib folder #import "..\Experts\library.ex5" // the file is located in the MQL5\Experts\ folder
Für Ihre zukünftige Verwendung können Funktionen nicht nur in die Ziel-.mq5-Datei, sondern auch in .mqh-Dateien importiert werden.
Nutzen wir ein paar Grafiken, um die praktische Anwendung zu illustrieren.
Wir erstellen eine Bibliothek von Funktionen für den Export. Diese Funktionen werden grafische Objekte wie Button, Edit, Label und Rectangle Label in einem Diagramm anzeigen, die Objekte aus dem Diagramm löschen und die Farbparameter des Diagramms zurücksetzen.
Schematisch lässt sich dies wie folgt darstellen:
Die vollständige Datei Graph.mq5 finden Sie am Ende des Beitrags. Hier führen wir nur ein Vorlagebeispiel der Zeichenfunktion Edit auf.
//+------------------------------------------------------------------+ //| SetEdit | //+------------------------------------------------------------------+ void SetEdit(long achart,string name,int wnd,string text,color txtclr,color bgclr,color brdclr, int x,int y,int dx,int dy,int corn=0,int fontsize=8,string font="Tahoma",bool ro=false) export { ObjectCreate(achart,name,OBJ_EDIT,wnd,0,0); ObjectSetInteger(achart,name,OBJPROP_CORNER,corn); ObjectSetString(achart,name,OBJPROP_TEXT,text); ObjectSetInteger(achart,name,OBJPROP_COLOR,txtclr); ObjectSetInteger(achart,name,OBJPROP_BGCOLOR,bgclr); ObjectSetInteger(achart,name,OBJPROP_BORDER_COLOR,brdclr); ObjectSetInteger(achart,name,OBJPROP_FONTSIZE,fontsize); ObjectSetString(achart,name,OBJPROP_FONT,font); ObjectSetInteger(achart,name,OBJPROP_XDISTANCE,x); ObjectSetInteger(achart,name,OBJPROP_YDISTANCE,y); ObjectSetInteger(achart,name,OBJPROP_XSIZE,dx); ObjectSetInteger(achart,name,OBJPROP_YSIZE,dy); ObjectSetInteger(achart,name,OBJPROP_SELECTABLE,false); ObjectSetInteger(achart,name,OBJPROP_READONLY,ro); ObjectSetInteger(achart,name,OBJPROP_BORDER_TYPE,0); ObjectSetString(achart,name,OBJPROP_TOOLTIP,""); }
Der Import der erforderlichen Funktionen und deren Verwendung werden in der Zieldatei Spiro.mq5 umgesetzt:
Example 3. Using imported functions //--- Spiro.mq5 – the target file of the Expert Advisor //--- importing some graphics functions #import "Graph.ex5" void SetLabel(long achart, string name, int wnd, string text, color clr, int x, int y, int corn=0, int fontsize=8, string font="Tahoma"); void SetEdit(long achart, string name, int wnd, string text, color txtclr, color bgclr, color brdclr, int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool ro=false); void SetButton(long achart, string name, int wnd, string text, color txtclr, color bgclr, int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool state=false); void HideChart(long achart, color BackClr); #import //--- prefix for chart objects string sID; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ void OnInit() { HideChart(0, clrWhite); sID="spiro."; DrawParam(); } //+------------------------------------------------------------------+ //| DrawParam | //+------------------------------------------------------------------+ void DrawParam() { color bgclr=clrWhite, clr=clrBlack; //--- bigger radius SetLabel(0, sID+"stR.", 0, "R", clr, 10, 10+3); SetEdit(0, sID+"R.", 0, "100", clr, bgclr, clr, 40, 10, 50, 20); //--- smaller radius SetLabel(0, sID+"str.", 0, "r", clr, 10, 35+3); SetEdit(0, sID+"r.", 0, "30", clr, bgclr, clr, 40, 35, 50, 20); //--- distance to the center SetLabel(0, sID+"stD.", 0, "D", clr, 10, 60+3); SetEdit(0, sID+"D.", 0, "40", clr, bgclr, clr, 40, 60, 50, 20); //--- drawing accuracy SetLabel(0, sID+"stA.", 0, "Alfa", clr, 10, 85+3); SetEdit(0, sID+"A.", 0, "0.04", clr, bgclr, clr, 40, 85, 50, 20); //--- drawing accuracy SetLabel(0, sID+"stN.", 0, "Rotor", clr, 10, 110+3); SetEdit(0, sID+"N.", 0, "10", clr, bgclr, clr, 40, 110, 50, 20); //--- draw button SetButton(0, sID+"draw.", 0, "DRAW", bgclr, clr, 39, 135, 51, 20); }
Nach der Ausführung des Expert Advisor erscheinen die Objekte im Diagramm:
Wie Sie sehen können, ist der Prozess für den Export und Import von Funktionen überhaupt nicht schwierig, aber lesen Sie dennoch die Informationen über bestimmte Einschränkungen in der Hilfe: export, import.
2. Export der verborgenen Umsetzung einer Klasse
Da Klassen in MQL5 aktuell nicht direkt exportiert werden können, müssen wir auf eine recht anspruchsvolle Methode zurückgreifen. Sie basiert auf Polymorphie und virtuellen Funktionen. Tatsächlich wird nicht die Klasse selbst aus dem ex5-Modul ausgegeben, sondern ein erstelltes Objekt von ihr. Nennen wir es das Objekt der verborgenen Umsetzung.
Der Sinn dieser Methode ist es, die erforderliche Klasse in zwei Klassen aufzuteilen, sodass die Deklarierung von Funktionen und Variablen öffentlich zugänglich ist und ihre Umsetzungsdetails in einer geschlossenen .ex5-Datei verborgen sind.
Dies lässt sich folgendermaßen veranschaulichen. Wir haben die Klasse CSpiro, die wir mit anderen Entwicklern teilen möchten, ohne ihre Umsetzungsdetails offenzulegen. Nehmen wir an, sie enthält Variablen, einen Konstruktor, einen Destruktor und Arbeitsfunktionen.
Um die Klasse zu exportieren, müssen wir Folgendes tun:
- Einen Klon des Nachfahren der Klasse CSpiro erstellen. Nennen wir ihn ISpiro (das C wird durch ein I ersetzt, abgeleitet vom Wort "interface").
- Alle Variablen und Dummy-Funktionen in der ursprünglichen Klasse CSpiro belassen.
- Die Umsetzungsdetails der Funktionen formen die neue Klasse ISpiro.
- Diese Klasse zur Exportfunktion hinzufügen, die eine Instanz der geschlossenen Klasse ISpiro erstellt.
- Hinweis! Alle erforderlichen Funktionen müssen das Präfix virtual haben.
Als Ergebnis erhalten wir zwei Dateien:
Example 4. Hiding of the class implementation in the ex5 module //--- Spiro.mqh – public file, the so called header file //+------------------------------------------------------------------+ //| Class CSpiro | //| Spirograph draw class | //+------------------------------------------------------------------+ class CSpiro { public: //--- prefix of the chart objects string m_sID; //--- offset of the chart center int m_x0,m_y0; //--- color of the line color m_clr; //--- chart parameters double m_R,m_r,m_D,m_dAlfa,m_nRotate; public: //--- constructor CSpiro() { }; //--- destructor ~CSpiro() { }; virtual void Init(int ax0,int ay0,color aclr,string asID) { }; virtual void SetData(double aR,double ar,double aD,double adAlpha,double anRotate) { }; public: virtual void DrawSpiro() { }; virtual void SetPoint(int x,int y) { }; };
Beachten Sie, dass alle Funktionen der Klasse mit dem Schlüsselwort virtual deklariert werden.
//--- ISpiro.mq5 – hidden implementation file #include "Spiro.mqh" //--- importing some functions #import "..\Experts\Spiro\Graph.ex5" void SetPoint(long achart,string name,int awnd,int ax,int ay,color aclr); void ObjectsDeleteAll2(long achart=0,int wnd=-1,int type=-1,string pref="",string excl=""); #import CSpiro *iSpiro() export { return(new ISpiro); } //+------------------------------------------------------------------+ //| Сlass ISpiro | //| Spirograph draw class | //+------------------------------------------------------------------+ class ISpiro : public CSpiro { public: ISpiro() { m_x0=0; m_y0=0; }; ~ISpiro() { ObjectsDeleteAll(0,0,-1); }; virtual void Init(int ax0,int ay0,color aclr,string asID); virtual void SetData(double aR,double ar,double aD,double adAlpha,double anRotate); public: virtual void DrawSpiro(); virtual void SetPoint(int x,int y); }; //+------------------------------------------------------------------+ //| Init | //+------------------------------------------------------------------+ void ISpiro::Init(int ax0,int ay0,color aclr,string asID) { m_x0=ax0; m_y0=ay0; m_clr=aclr; m_sID=asID; m_R=0; m_r=0; m_D=0; } //+------------------------------------------------------------------+ //| SetData | //+------------------------------------------------------------------+ void ISpiro::SetData(double aR,double ar,double aD,double adAlpha,double anRotate) { m_R=aR; m_r=ar; m_D=aD; m_dAlfa=adAlpha; m_nRotate=anRotate; } //+------------------------------------------------------------------+ //| DrawSpiro | //+------------------------------------------------------------------+ void ISpiro::DrawSpiro() { if(m_r<=0) { Print("Error! r==0"); return; } if(m_D<=0) { Print("Error! D==0"); return; } if(m_dAlfa==0) { Print("Error! Alpha==0"); return; } ObjectsDeleteAll2(0,0,-1,m_sID+"pnt."); int n=0; double a=0; while(a<m_nRotate*2*3.1415926) { double x=(m_R-m_r)*MathCos(a)+m_D*MathCos((m_R-m_r)/m_r*a); double y=(m_R-m_r)*MathSin(a)-m_D*MathSin((m_R-m_r)/m_r*a); SetPoint(int(m_x0+x),int(m_y0+y)); a+=m_dAlfa; } ChartRedraw(0); } //+------------------------------------------------------------------+ //| SetPoint | //+------------------------------------------------------------------+ void ISpiro::SetPoint(int x,int y) { Graph::SetPoint(0,m_sID+"pnt."+string(x)+"."+string(y),0,x,y,m_clr); } //+------------------------------------------------------------------+
Wie Sie sehen können, wurde die verborgene Klasse in einer .mq5-Datei umgesetzt und enthält den Präprozessor-Befehl #property library. Das bedeutet, dass alle im vorherigen Abschnitt dargelegten Regeln beachtet wurden.
Beachten Sie auch den Operator Operation mit Kontexterlaubnis für die Funktion SetPoint. Er wird sowohl in der Bibliothek Graph als auch in der Klasse CSpiro deklariert. Damit der Compiler die erforderliche Funktion aufrufen kann, bestimmen wir sie explizit mit der Operation :: und geben den Dateinamen an.
Graph::SetPoint(0, m_sID+"pnt."+string(x)+"."+string(y), 0, x, y, m_clr);
Wir können nun die Kopfzeilendatei einfügen und Ihre Umsetzung in den resultierenden Expert Advisor importieren.
Schematisch lässt sich dies wie folgt darstellen:
Example 5. Using export objects //--- Spiro.mq5 - the target file of the Expert Advisor //--- importing some functions #import "Graph.ex5" void SetLabel(long achart, string name, int wnd, string text, color clr, int x, int y, int corn=0, int fontsize=8, string font="Tahoma"); void SetEdit(long achart, string name, int wnd, string text, color txtclr, color bgclr, color brdclr, int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool ro=false); void SetButton(long achart, string name, int wnd, string text, color txtclr, color bgclr, int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool state=false); void HideChart(long achart, color BackClr); #import //--- including the chart class #include <Spiro.mqh> //--- importing the object #import "ISpiro.ex5" CSpiro *iSpiro(); #import //--- object instance CSpiro *spiro; //--- prefix for chart objects string sID; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ void OnInit() { HideChart(0, clrWhite); sID="spiro."; DrawParam(); //--- object instance created spiro=iSpiro(); //--- initializing the drawing spiro.Init(250, 200, clrBlack, sID); //--- setting the calculation parameters spiro.SetData(100, 30, 40, 0.04, 10); //--- drawing spiro.DrawSpiro(); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { delete spiro; // deleting the object }
Als Ergebnis erhalten Sie die Möglichkeit, die Objektparameter im Diagramm zu ändern und das Diagramm des Objekts zu zeichnen.
3. Initialisierung von Variablen in .ex5-Dateien
Es geschieht häufig, dass Ihre ISuperClass Variablen aus der Include-Datei globals.mqh nutzt. Diese Variablen lassen sich ähnlich einbeziehen und in Ihren anderen Dateien verwenden.
Z. B.:
Example 6. Public include file //--- globals.mqh #include <Trade\Trade.mqh> //--- instance of the trade function object extern CTrade *_trade;
Die einzige Instanz des Objekts _trade wird in Ihrem Programm initialisiert, wird aber in der verborgenen Klasse ISuperClass verwendet.
Zu diesem Zweck muss ein Pointer zu dem von Ihnen erstellen Objekt von der Klasse ISuperClass an die .ex5-Datei übergeben werden.
Dies lässt sich am einfachsten bewerkstelligen, wenn das Objekt von der .ex5-Datei empfangen wird, wie nachfolgend dargestellt:
Example 7. Initialization of variables upon creation of the object //--- ISuperClass.mq5 –hidden implementation file #property library CSuperClass *iSuperClass(CTrade *atrade) export { //--- saving the pointer _trade=atrade; //--- returning the object of the hidden implementation of ISuperClass of the open CSuperClass class return(new ISuperClass); } //... the remaining code
Somit werden alle erforderlichen Variablen beim Empfang des Objekts in seinem Modul initialisiert.
Tatsächlich kann es viele öffentliche globale Variablen geben, die zu verschiedenen Typen gehören können. Wer nicht darauf erpicht ist, die Kopfzeile der Funktion iSuperClass ständig zu ändern, sollte besser eine spezielle Sammelklasse erstellen, die alle globalen Variablen und Funktionen für die Arbeit mit ihr sammelt.
Example 8. Public include file //--- globals.mqh #include <Trade\Trade.mqh> //--- trade "object" extern CTrade *_trade; //--- name of the Expert Advisor of the system extern string _eaname; //+------------------------------------------------------------------+ //| class __extern | //+------------------------------------------------------------------+ class __extern // all extern parameters for passing between the ex5 modules are accumulated here { public: //--- the list of all public global variables to be passed //--- trade "object" CTrade *trade; //--- name of the Expert Advisor of the system string eaname; public: __extern() { }; ~__extern() { }; //--- it is called when passing the parameters into the .ex5 file void Get() { trade=_trade; eaname=_eaname; }; // getting the variables //--- it is called in the .ex5 file void Set() { _trade=trade; _eaname=eaname; }; // setting the variables }; //--- getting the variables and pointer for passing the object into the .ex5 file __extern *_GetExt() { _ext.Get(); return(GetPointer(_ext)); } //--- the only instance for operation extern __extern _ext;Die Datei ISuperClass.mq5 wird folgendermaßen umgesetzt:
Example 9. //--- ISuperClass.mq5 –hidden implementation file #property library CSuperClass *iSuperClass(__extern *aext) export { //--- taking in all the parameters aext.Set();//--- returning the object return(new ISuperClass); } //--- ... the remaining code
Der Aufruf der Funktion wird nun in eine einfachere und vor allem erweiterbare Variante umgewandelt.
Example 10. Using export objects in the presence of public global variables //--- including global variables (usually located in SuperClass.mqh) #include "globals.mqh" //--- including the public header class #include "SuperClass.mqh" //--- getting the hidden implementation object #import "ISuperClass.ex5" CSuperClass *iSuperClass(); #import //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- creating the hidden implementation object providing for the passing of all parameters CSuperClass *sc=iSuperClass(_GetExt()); //--- ... the remaining code }
4. Vererbung von Export-Klassen
Es hat sich bereits herauskristallisiert, dass diese Art des Exports von Objekten bedeutet, dass die direkte und einfache Vererbung nicht in Frage kommt. Der Export der verborgenen Umsetzung deutet darauf hin, dass das Objekt selbst das letzte Glied der Vererbungskette ist und letztendlich verwendet werden kann.
Im Allgemeinen können Sie die Vererbung "emulieren", indem Sie eine zusätzliche Zwischenklasse schreiben. Und hier brauchen wir natürlich Polymorphie und Virtualität.
Example 11. Emulation of inheritance of hidden classes //--- including the public header class #include "SuperClass.mqh" //--- getting the hidden implementation object #import "ISuperClass.ex5" CSuperClass *iSuperClass(); #import class _CSuperClass { public: //--- instance of the hidden implementation object CSuperClass *_base; public: //--- constructor _CSuperClass() { _base=iSuperClass(_GetExt()); }; //--- destructor ~_CSuperClass() { delete _base; }; //--- further followed by all functions of the base CSuperClass class //--- working function called from the hidden implementation object virtual int func(int a, int b) { _base.func(a,b); }; };
Das einzige Problem ist hierbei der Zugriff auf die Variablen von CSuperClass. Wie Sie sehen können, fehlen sie in der Deklarierung des Nachfahren und befinden sich in der Variable _base. Dies wirkt sich für gewöhnlich nicht auf die Benutzerfreundlichkeit aus, solange es die Kopfzeilenklasse SuperClass.mqh gibt.
Wenn Sie sich natürlich hauptsächlich auf Know-how-Funktionen konzentrieren, müssen Sie nicht vorab einen Wrapper von ISuperClass dafür erstellen. Es reicht, diese Know-how-Funktionen zu exportieren und die Fremdentwickler ihre eigenen Wrapper-Klassen erstellen zu lassen, die dann einfach vererbt werden können.
- Export klassenunabhängiger Funktionen
- Kopfzeilen-.mqh-Dateien und ihre .ex5-Umsetzungen
- Initialisierung von Variablen in den .ex5-Dateien
5. Veröffentlichen von ex5-Bibliotheken
Seit November 2011 bietet MetaQuotes einen Zugang zu einer Dateiablage. Mehr dazu finden Sie in der Ankündigung.
In dieser Ablage können Sie Ihre Entwicklungen speichern und, noch viel wichtiger, anderen Entwicklern den Zugriff darauf gewähren. Mit diesem Tool können Sie schnell und einfach neue Versionen Ihrer Dateien veröffentlichen, um Entwicklern, die diese Dateien möglicherweise nutzen, den schnellen Zugriff darauf zu ermöglichen.
Zudem liefert Ihnen die Webseite des Unternehmens eine Möglichkeit, Ihre eigenen Funktionsbibliotheken kommerziell oder kostenlos im Market anzubieten.
Fazit
Sie wissen nun, wie ex5-Bibliotheken mit dem Export ihrer Funktionen und Klassenobjekte erstellt werden, und können Ihr Wissen praktisch anwenden. Dank diesen Ressourcen können Sie enger mit anderen Entwicklern kooperieren, um an gemeinsamen Projekten zu arbeiten, sie auf dem Market zu bewerben oder Zugriff auf ex5-Bibliotheksfunktionen zu gewähren.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/362
Der letzte Kreuzzug
Die Kursbewegungen. Die Automatisierung der "Engulfing Pattern"-Handelsstrategie
AutoElliottWaveMaker - ein Tool für die halbautomatisierte Analyse von Elliott-Wellen in MetaTrader 5
Die Verwaltung des Handelsterminals MetaTrader via DLL
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.