Statische Mitglieder der Klasse/Struktur

Statische Mitglieder

Die Mitglieder der Klasse können mit der Storage-Klasse Modifier statisch deklariert werden. Diese Datenmitglieder werden von allen Instanzen dieser Klasse geteilt und sind an einem Ort gespeichert. Nicht-statische Datenmitglieder werden für jede Variable-Klassenobject erstellt.

Die Unfähigkeit, statische Mitglieder einer Klasse zu deklarieren, würde auf die Notwendigkeit, diese Daten auf der globalen Ebene des Programms zu deklarieren, geführt haben. Es würde die Beziehung zwischen den Daten und ihrer Klasse brechen und steht nicht im Einklang mit der grundlegenden Paradigma der OOP - die Zusammenführung von Daten und Methoden für Verarbeitung in einer Klasse. Ein statischer Mitglied ermöglicht Klassendaten, die auf eine bestimmte Instanz nicht spezifisch sind, im Gültigkeitsbereich der Klasse zu existieren.

Da eine statische Klasse Mitglied nicht von der jeweiligen Instanz abhängen, ist der Verweis auf ihn wie folgt:

class_name::variable

wo class_name – ist der Name der Klasse, variable ist der name des Mitglieds der Klasse.

Ein statisches Klassenmitglied muss explizit mit den gewünschten Wert initialisiert werden. Um dies zu tun, muss es auf globaler Ebene deklariert und initialisiert werden. Die Reihenfolge der Initialisierung von statischen Mitglieder entspricht der Reihenfolge, in der sie auf der globalen Ebene im Quellcode deklariert sind.

Zum Beispiel haben wir eine Klasse CParser, die zum Parsen der Text verwendet wird, und wir brauchen die Gesamtzahl der verarbeiteten Wörter und Zeichen zu zählen. Wir müssen nur die notwendigen Klassenmitglieder als statische deklarieren und sie auf globaler Ebene initialisieren. Dann werden alle Instanzen der Klasse den Zähler von Wörtern und Zeichen gemeinsam nutzen.

//+------------------------------------------------------------------+
//| Klasse "Text Parser"                                             |
//+------------------------------------------------------------------+
class CParser
  {
public:
   static int        s_words;
   static int        s_symbols;
   //--- Konstruktor und Destruktor
                     CParser(void);
                    ~CParser(void){};
  };
...
//--- Initialisierung von statischen Mitglieder der Klasse Parser auf globaler Ebene
int CParser::s_words=0;
int CParser::s_symbols=0;

Ein statisches Klassenmitglied kann mit dem Schlüsselwort const deklariert werden. Solche statischen Konstanten müssen auf globaler Ebene mit dem Schlüsselwort const initialisiert werden:

//+------------------------------------------------------------------+
//| Klasse "Stack" zur Speicherung der Daten, die verarbeitet werden |
//+------------------------------------------------------------------+
class CStack
  {
public:
                     CStack(void);
                    ~CStack(void){};
...
private:
   static const int  s_max_length; // Maximale Kapazität des Stacks
  };

//--- initialisierung der statischen Konstanten der Klasse CStack
const int CStack::s_max_length=1000;

Zeiger this #

Das Schlüsselwort this bedeutet implizit deklarierten Zeiger auf sich selbst - auf eine bestimmte Instanz der Klasse, in deren Rahmen die Methode ausgeführt wird. Es kann nur in nicht-statische Methoden der Klasse verwendet werden. Zeiger this ist ein implizites nicht-statisches Mitglied einer beliebigen Klasse.

In statischen Funktionen können Sie nur statische Mitglieder/Methoden einer Klasse zugreifen.

Statische Methoden

In MQL5 Mitgliederfunktionen vom Typ static können verwendet werden. Modifikator static muss vor dem Rückgabetyp der Funktion in der Deklaration innerhalb einer Klasse gehen.

class CStack
  {
public:
   //--- Konstruktor und Destruktor
                     CStack(void){};
                    ~CStack(void){};
   //--- Maximale Kapazität des Stacks
   static int        Capacity();
private:
   int               m_length;     // Anzahl der Elemente im Stack
   static const int  s_max_length; // Maximale Kapazität des Stacks
  };
//+------------------------------------------------------------------+
//| Gibt maximale Anzahl der Elemente im Stack zu speichern zurück   |
//+------------------------------------------------------------------+
int CStack::Capacity(void)
  {
   return(s_max_length);
  }
//--- initialisierung der statischen Konstanten der Klasse CStack
const int CStack::s_max_length=1000;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- eine Variable vom Typ CStack deklarieren
   CStack stack;
//--- die statische Objektmethode anrufen
   Print("CStack.s_max_length=",stack.Capacity());
//--- es ist auch möglich so anzurufen, da die Methode statisch ist und kein Objekt erfordert
   Print("CStack.s_max_length=",CStack::Capacity());
;}

Eine Methode mit Modifikator const heißt konstant und kann nicht implizite Mitglieder ihrer Klasse ändern. Die Deklaration der konstanten Funktionen einer Klasse und konstanten Parametern ist Kontrolle der Konstanz (const-correctness). Durch diese Kontrolle können Sie sicher sein, dass der Compiler die Konsistenz der Werte der Objekte gewährleistet und wird einen Fehler während der Kompilierung zurückgeben, wenn etwas falsch ist.

Modifikator const wird nach der Liste von Argumenten innerhalb einer Klassendeklaration platziert. Definition außerhalb einer Klasse sollte auch die Modifikator const haben:

//+------------------------------------------------------------------+
//| Klasse "Rechteck"                                                |
//+------------------------------------------------------------------+
class CRectangle
  {
private:
   double            m_width;      // Breite
   double            m_height;     // Höhe
public:
   //--- Konstruktoren und Destruktor
                     CRectangle(void):m_width(0),m_height(0){};
                     CRectangle(const double w,const double h):m_width(w),m_height(h){};
                    ~CRectangle(void){};
   //--- Berechnung der Fläche
   double            Square(void) const;
   static double     Square(const double w,const double h);// { return(w*h); }
  };
//+------------------------------------------------------------------+
//| Gibt die Fläche des Objekts "Rechteck" zurück                    |
//+------------------------------------------------------------------+
double CRectangle::Square(void) const
  {
   return(Square(m_width,m_height));
  }
//+------------------------------------------------------------------+
//| Gibt das Produkt von zwei Variablen zurück                       |
//+------------------------------------------------------------------+
static double CRectangle::Square(const double w,const double h)
  {
   return(w*h);
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- erstellen wir ein Rechteck rect mit Seiten 5 und 6
   CRectangle rect(5,6);
//--- finden wir Fläche eines Rechtecks mit der konstanten Methode
   PrintFormat("rect.Square()=%.2f",rect.Square());
//--- finden wir das Produkt der Zahlen mit der statischen Methode der CRectangle-Klasse
   PrintFormat("CRectangle::Square(2.0,1.5)=%f",CRectangle::Square(2.0,1.5));
  }

Ein zusätzliches Argument für die Verwendung der Konstanz Kontrolle ist die Tatsache, dass in diesem Fall der Compiler eine spezielle Optimierung erzeugt, zum Beispiel, hat ein konstantes Objekt im Nurlesespeicher.

Eine statische Funktion kann nicht mit einem Modifikator const definiert werden, da dies Modifikator die Unveränderlichkeit von den Mitgliedern der Instanz garantiert, wenn diese Funktion aufgerufen wird. Aber, wie oben erwähnt, kann die statische Funktion nicht-statische Mitgliedern der Klasse nicht zugreifen.

Sehen Sie auch

Statische Variablen, Variablen, Referenzen. Modifikator & und Schlüsselwort this

Virtuelle Funktionen

Funktionstemplates