Nachschlagewerk MQL5Allgemeine FunktionenGetPointer

GetPointer

Gibt Anzeiger des Objektes zurück.

void*  GetPointer(
   any_class anyobject      // Objekt jeder Klasse
   );

Parameter

anyobject

[in] Objekt jeder Klasse.

Rückgabewert

Gibt Objektanzeiger zurück.

Hinweis

Nur Klassenobjekte haben Anzeiger. Instanzen der Strukturen und Variablen einfacher Typen haben keine Anzeiger. Klassenobjekt, das nicht nurch die Anweisung new(), sondern ZB. automatisch im Feld der Objekte erzeugt wurde, hat trotzdem einen Anzeiger.Dieser Anzeiger wird aber des automatischen Typs POINTER_AUTOMATIC sein, darum kann die Anweisung delete() nicht angewendet werden. Sonst unterscheidet sich die Anweisung dieses Typs nicht von den Anzeigern des Typs POINTER_DYNAMIC.

Da Variablen des Typs Strukturen und einfacher Typen keine Anzeiger haben, ist es verboten, die Funktion GetPointer() für sie anzuwenden. Man darf auch nicht Anzeiger als Argument der Funktion zu übertragen. In allen genannten Faellen meldet der Compiler den Fehler.

Versuch der Anwendung zum unkorrekten Anzeiger führt zur kritischen Beendigung des Programms. Darum besteht es die Notwendigkeit, die Funktion CheckPointer() vor dem Gebrauch des Anzeigers zu verwenden. Anzeiger kann in folgenden Faellen unkorrekt sein:

Anzeiger ist NULL gleich;
wenn Objekt durch die Anweisung delete entfernt wurde.

Diese Funktion kann als Pruefung des Anzeigers auf Validitaet verwendet werden. Nicht-Null Wert garantiert, dass Anzeiger für Zugang verwendet werden kann.

Beispiel:

//+------------------------------------------------------------------+
//|                                             Check_GetPointer.mq5 |
//|                         Copyright 2000-2024, MetaQuotes Ltd. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2009, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

//+------------------------------------------------------------------+
//| Klasse, implementierte Element der Liste                         |
//+------------------------------------------------------------------+
class CItem
  {
   int               m_id;
   string            m_comment;
   CItem*            m_next;
public:
                     CItem() { m_id=0; m_comment=NULL; m_next=NULL; }
                    ~CItem() { Print("Destructor of ",m_id,
                                     (CheckPointer(GetPointer(this))==POINTER_DYNAMIC)?
                                     "dynamic":"non-dynamic"); }
   void              Initialize(int id,string comm) { m_id=id; m_comment=comm; }
   void              PrintMe() { Print(__FUNCTION__,":",m_id,m_comment); }
   int               Identifier() { return(m_id); }
   CItem*            Next() {return(m_next); }
   void              Next(CItem *item) { m_next=item; }
  };
//+------------------------------------------------------------------+
//| Die einfachste Klasse der Liste                                  |
//+------------------------------------------------------------------+
class CMyList
  {
   CItem*            m_items;
public:
                     CMyList() { m_items=NULL; }
                    ~CMyList() { Destroy(); }
    bool             InsertToBegin(CItem* item);
    void             Destroy();
  };
//+------------------------------------------------------------------+
//| Einfuegung des Elementes der Liste am Anfang                     |
//+------------------------------------------------------------------+
bool CMyList::InsertToBegin(CItem* item)
  {
   if(CheckPointer(item)==POINTER_INVALID) return(false);
//---
   item.Next(m_items);
   m_items=item;
//---
   return(true);
  }
//+------------------------------------------------------------------+
//| Entfernung der Liste durch Entfernung der Elementen              |
//+------------------------------------------------------------------+
void CMyList::Destroy()
  {
//--- Dienstanzeiger für Arbeit im Zyklus
   CItem* item;
//--- gehen wir durch den Zyklus und versuchen wir, dynamische Anzeiger zu entfernen
   while(CheckPointer(m_items)!=POINTER_INVALID)
     {
      item=m_items;
      m_items=m_items.Next();
      if(CheckPointer(item)==POINTER_DYNAMIC)
        {
         Print("Dynamyc object ",item.Identifier()," to be deleted");
         delete (item);
        }
      else Print("Non-dynamic object ",item.Identifier()," cannot be deleted");
     }
//---
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   CMyList list;
   CItem   items[10];
   CItem*  item;
//--- erzeugen wir und fuegen in die Liste das dynamische Anzeiger des Objektes hinzu
   item=new CItem;
   if(item!=NULL)
     {
      item.Initialize(100,"dynamic");
      item.PrintMe();
      list.InsertToBegin(item);
     }
//--- fuegen wir automatische Anzeiger in die Liste hinzu
   for(int i=0; i<10; i++)
     {
      items[i].Initialize(i,"automatic");
      items[i].PrintMe();
      item=GetPointer(items[i]);
      if(CheckPointer(item)!=POINTER_INVALID)
         list.InsertToBegin(item);
     }
//--- fuegen wir noch einen dynamischen Anzeiger des Objektes am Anfang der Liste hinzu
   item=new CItem;
   if(item!=NULL)
     {
      item.Initialize(200,"dynamic");
      item.PrintMe();
      list.InsertToBegin(item);
     }
//--- entfernen wir Elementen der Liste
   list.Destroy();
//--- Alle Elementen der Liste werden entfernt werden,
//--- sieh im Terminal Registerblatt Experts
  }

Sehen Sie auch

Objektanzeiger, Pruefung des Objektanzeigers, Anweisung der Objektentfernung delete

ExpertRemove

GetTickCount