MetaTrader 5 herunterladen

Objektanzeiger

In MQL5 ist es moeglich, Objekte des komplizierten Typs dynamisch zu erzeugen. Das wird durch Anweisung new gemacht, die dem Deskriptor des erzeugten Objekts zurückgibt.  Der Deskriptor kann die Größe 8 Byte sein. Syntaktisch gesehen sind Objekte in  MQL5  den Objekten in C++ gleich.

Beispiele:

MyObject* hobject= new MyObject();

Im Gegensatz zu C++, ist die Variable hobject nicht ein Zeiger auf den Speicher, sondern ein Objekt-Deskriptor. Außerdem, in MQL5 müssen alle Objekte in den Funktion-Parametern als Referenz übergeben werden. Beispiele für Übergabe von Objekten als die Funktion-Parameter:

class Foo
  {
public:
   string            m_name;
   int               m_id;
   static int        s_counter;
   //--- Konstruktoren und Destruktoren
                     Foo(void){Setup("noname");};
                     Foo(string name){Setup(name);};
                    ~Foo(void){};
   //--- Initialisiert ein Objekt vom Typ Foo
   void              Setup(string name)
     {
      m_name=name;
      s_counter++;
      m_id=s_counter;
     }
  };
int Foo::s_counter=0;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- das Objekt als eine Variable mit dem automatischem Erstellen deklarieren
   Foo foo1;
//--- Variante wie das Objekt als Referenz zu übergeben
   PrintObject(foo1);
 
//--- Ein Zeiger auf das Objekt deklarieren und es durch den Operator 'new' erstellen
   Foo *foo2=new Foo("foo2");
//--- Variante wie das Objekt als Referenz zu übergeben
   PrintObject(foo2); // Der Zeiger auf das Objekt wird beim Compiler automatisch konvertiert
 
//--- Das Array von Objekten vom Typ Foo deklarieren
   Foo foo_objects[5];
//--- Variante wie das Array von Objekten zu übergeben
   PrintObjectsArray(foo_objects); // eine separate Funktion für die Übergabe eines Arrays von Objekten
 
//--- Das Array von Zeigern auf die Objekten vom Typ Foo deklarieren
   Foo *foo_pointers[5];
   for(int i=0;i<5;i++)
     {
      foo_pointers[i]=new Foo("foo_pointer");
     }
//--- Variante wie das Array von Zeigern zu übergeben
   PrintPointersArray(foo_pointers); // eine separate Funktion für die Übergabe eines Arrays von Zeigern
 
//--- Es ist wichtig, die Objekten die als Zeiger erstellt waren vor Beendung zu löschen
   delete(foo2);
//--- das Array von Zeigern löschen
   int size=ArraySize(foo_pointers);
   for(int i=0;i<5;i++)
      delete(foo_pointers[i]);
//---   
  }
//+------------------------------------------------------------------+
//| Objekten werden immer als Referenz übergeben                     |
//+------------------------------------------------------------------+
void PrintObject(Foo &object)
  {
   Print(__FUNCTION__,": ",object.m_id," Object name=",object.m_name);
  }
//+------------------------------------------------------------------+
//| Übergabe eines Arrays von Objekten                               |
//+------------------------------------------------------------------+
void PrintObjectsArray(Foo &objects[])
  {
   int size=ArraySize(objects);
   for(int i=0;i<size;i++)
     {
      PrintObject(objects[i]);
     }
  }
//+------------------------------------------------------------------+
//| Übergabe eines Arrays von Zeigern auf Objekt                     |
//+------------------------------------------------------------------+
void PrintPointersArray(Foo* &objects[])
  {
   int size=ArraySize(objects);
   for(int i=0;i<size;i++)
     {
      PrintObject(objects[i]);
     }
  }
//+------------------------------------------------------------------+

Sehen Sie auch

Variablen, Initialisierung der Variablen, Sichtbereich und Lebensdauer der Variablen, Erzeugung und Entfernung der Objekte