Statische Elemente (C++)

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Das Schlüsselwort this


Der Speicherklassen-Spezifizierer static kann in Deklarationen von Daten- und Funktionselementen verwendet werden. Derartige Elemente heißen statische Elemente. Sie unterscheiden sich eindeutig von nicht-statischen Elementen. Bei nicht-statischen Elementen "existiert" für jede Klasseninstanz eine eigene Kopie, bei den statischen Elementen ist nur eine Kopie vorhanden. Auf diese kann ohne Referenz auf ein bestimmtes Objekt dieser Klasse zugegriffen werden. Ist x ein statisches Element der Klasse X, dann kann über X::x darauf verwiesen werden (auch dann, wenn noch keine Objekte der Klasse X erzeugt wurden). Es ist weiterhin mögilch, auf x mit Hilfe der üblichen Elementzugriffsoperatoren zuzugreifen. Zum Beispiel: y.x und yptr‑>x, wobei y ein Objekt der Klasse X ist und yptr ein Zeiger auf ein Objekt der Klasse X, obwohl die Ausdrücke y und yptr nicht ausgewertet sind. Eine statische Elementfunktion kann mit oder ohne spezielle Elementfunktion-Syntax aufgerufen werden:

class X {
   int member_int;
public:
   static void func(int i, X* ptr);
};
void g(void)
{
   X obj;
   func(1, &obj);      // Fehler, wenn es keine globale func()
                       // gibt, die anderweitig definiert ist.
   X::func(1, &obj);   // ruft static func() in X auf
                       // nur für statische Funktionen
   obj.func(1, &obj);  // ebenso (für statische und
                       // nicht-statische Funktionen)
}

Da eine statische Elementfunktion ohne ein spezielles Objekt aufgerufen werden kann, hat sie keinen this-Zeiger. Sie kann daher nicht ohne explizite Angabe eines Objekts mit . oder -> auf nicht-statische Elemente zugreifen. Wenn wir das vorherige Beispiel zugrunde legen, könnte func z.B. wie folgt definiert werden:

void X::func(int i, X* ptr)
{
   member_int = i;       // Auf welches Objekt bezieht sich
                         // member_int? Fehler
   ptr->member_int = i;  // OK: Jetzt wissen wir Bescheid!
}

Abgesehen von Inline-Funktionen haben statische Elementfunktionen globaler Klassen externe Bindung. Statische Elementfunktionen können keine virtuellen Funktionen sein. Es ist nicht erlaubt, eine statische und eine nicht-statische Elementfunktion mit demselben Namen und denselben Argumenttypen zu versehen.

Die Deklaration eines statischen Datenelements innerhalb seiner Klasse ist noch keine Definition. Die Definition muss deshalb an anderer Stelle erfolgen, um Speicherplatz zu reservieren und eine Initialisierung durchzuführen.

Statische Elemente einer Klasse, die lokal zu einer Funktion deklariert sind, haben keine Bindung und können nicht initialisiert werden. Statische Elemente einer globalen Klasse können wie normale globale Objekte initialisiert werden, allerdings nur im Gültigkeitsbereich einer Datei. Abgesehen davon, dass sie initialisiert werden können, gehorchen beliebig tief geschachtelte statische Elemente den normalen Zugriffsregeln für Klassen.

class X {
   static int x;
   static const int size =  5;
   class inner {
      static float f;
      void func(void);     // verschachtelte Deklartion
      };
public:
   char array[size];
};
int X::x = 1;
float X::inner::f = 3.14;  // Initialisierung der geschachtelten statischen Funktion
void X::inner::func(void) {    /* Definition der geschachtelten Funktion */  }

Der Hauptzweck statischer Elemente ist es, Daten aufzunehmen, die allen Objekten einer Klasse gemeinsam sind (z.B. die Anzahl von erzeugten Objekten oder die zuletzt verwendete Ressource aus einem Pool, aus dem sich alle diese Objekte bedienen). Statische Elemente werden außerdem genutzt, um

  • Die Anzahl der sichtbaren globalen Namen zu reduzieren:
  • Offensichtlich zu machen, welches statische Objekt logisch zu welcher Klasse gehört:
  • Den Zugriff auf ihre Namen zu erlauben.

Siehe auch