static (Schlüsselwort)

Die Speicherklasse (englisch storage class) static definiert die „Lebenszeit“ einer Variable.

Die Lebenszeit einer globalen Variablen (Variablen auf Modul-/Dateiebene) beginnt mit dem Programmstart (bei globalen Variablen) und endet mit dem Ende des Programms: Sie haben stets die Speicherklasse „static“ (engl. static storage duration). Hingegen kann man auf Methodenebene mithilfe des Schlüsselwortes static die Speicherklasse beeinflussen. Standardmäßig ist die Lebensdauer von Variablen auf Methodenebene auf den Methodenaufruf beschränkt, sie werden also beim Verlassen der Methode wieder entfernt. Variablen mit dem Schlüsselwort static besitzen hingegen die Speicherklasse static und behalten ihre Werte daher auch über den Methodenaufruf hinweg. Das Gegenstück zum static-Schlüsselwort in diesem Kontext ist das Weglassen des Schlüsselwortes (oder in C das Verwenden des auto-Schlüsselwortes).

Bei rein prozeduralen Programmiersprachen wird das Schlüsselwort in diesem Kontext gerne verwendet, um eine möglichst geringe Sichtbarkeit der Variablen zu erreichen. Alternative zu einer Variable in einer Methode mit statischer Speicherklasse ist eine Variable auf Modul-/Dateiebene, die durch den Linker nicht zur Verfügung gestellt wird (siehe #Linkage). Diese ist jedoch auch von einer anderen Methode im selben Modul/Datei zugreifbar.

In objektorientierten Programmiersprachen stehen für eine möglichst geringe Sichtbarkeit gut geeignete Alternativen zur Verfügung. Zudem erfordern die Kapselungskonzepte häufig auch methodenübergreifenden Zugriff. Größte Einschränkung ist aber, dass Variablen häufig im Klassenkontext benötigt werden, während Variablen der static storage duration klassenübergreifend arbeiten. Daher wird das Schlüsselwort in dieser Bedeutung dort erheblich seltener verwendet. Benötigt man doch static storage duration setzt man stattdessen auf private statische (siehe #static und Shared bei Klassenmembern) Klassenvariablen, die auch für andere Methoden der Klasse zugreifbar sind, aber dafür viel besser in die Systematik des objektorientierten Programmierens passt.

Die Bedeutung von static als Speicherklasse kann in C und C++ angewendet werden. In Visual Basic Classic wurde das Schlüsselwort (übliche Schreibweise: Static) ebenfalls eingeführt und in Visual Basic .Net aus Kompatibilitätsgründen übernommen. C# hingegen verzichtet zugunsten einer eindeutigen Bedeutung des static-Schlüsselwortes auf diese Bedeutung des Schlüsselwortes.

int summiere(int s)
{
    static int summe = 100; // Variable wird beim ersten Durchlauf initialisiert.
    summe += s;
    return summe;
}

Public Function Summiere(ByVal s As Integer) As Integer
  Static summe As Integer = 100
  summe += s
  Return summe
End Function

Die Linkage eines Symbols (wie z. B. eines Variablen- oder Funktionsnamens) gibt an, wie mit dem Symbol beim Linken umgegangen wird.

Globale Variablen haben in C standardmäßig external linkage, das heißt, sie sind von anderen Übersetzungseinheiten aus sichtbar und existieren nur einmal im endgültigen Programm. Alle Methoden greifen auf dieselbe Variable zu. Wird ein Symbol mit external linkage in mehreren Übersetzungseinheiten definiert (und nicht bloß deklariert!), gibt es beim Linken einen Linkerfehler (double definition error), da unklar ist, welche der beiden Variablen in allen übrigen Übersetzungseinheiten verwendet werden soll.

Um Variablen und Funktionen jeweils pro Übersetzungseinheit zu definieren, muss man sie mit internal linkage deklarieren. Dies geschieht in C und C++ durch das Schlüsselwort static bei der Deklaration einer globalen Variable oder Funktion. Die Variable/Funktion wird nun dem Linker nicht mehr zur Verfügung gestellt, so dass die anderen Übersetzungseinheiten nicht mehr (direkt) auf sie zugreifen können (Zugriffsmodifikator). Gleichzeitig besteht dadurch für andere Übersetzungseinheiten die Möglichkeit, Variablen und Funktionen zu definieren, die zwar denselben Namen, aber dennoch nichts miteinander zu tun haben.

Die Verwendung des static-Schlüsselwortes zu Linkage-Zwecken existiert nur in C und C++. Java, C# und VB(.Net) haben keine Linker in dieser Form und erlauben die Definition von Variablen auf Modul/Dateiebene auch nicht.

Bei prozeduraler Programmierung gilt die Verwendung des Schlüsselwortes bei allen Methoden, die nicht von außen zugreifbar sein sollen, und bei allen Variablen, als guter Stil. (Bei Bedarf erfolgt der Zugriff auf die Variablen über einen Getter und einen Setter als Zugriffsfunktion.) Bei der Trennung zwischen Modulinterface (.h-Datei) und Code (.c-Datei) werden intern gelinkte Member im Gegensatz zu extern gelinken nicht in der .h-Datei deklariert, sondern befinden sich ausschließlich in der .c-Datei.

    static int x; // internal linkage
    extern int y; // nur Deklaration!
                  // => nicht alleine Lauffähig.
    int z;        // external linkage in beiden Dateien

    const int c = 42; // external linkage in C, internal in C++

    static int f() {return 0;} // internal linkage
    int g();                   // nur Deklaration!
                               // => nicht alleine Lauffähig.
    int h() {return 2;}        // external linkage in beiden Dateien

    static int x; // internal linkage
    int y;        // external linkage, ergänzt beim Zusammenlinken
                  // die Deklaration in foo.c um die Definition.
    int z;        // external linkage in beiden Dateien => Fehler

    const int c = 42; // external linkage in C, internal in C++

    static int f() {return 0;} // internal linkage
    int g() {return 1;}        // external linkage, ergänzt beim Zusammenlinken
                               // die Deklaration in foo.c um die Definition.
    int h() {return 2;}        // external linkage in beiden Dateien => Fehler

In Sprachen mit Klassen kann es Klassenfunktionen geben, die etwas mit der Klasse zu tun haben, aber keinerlei Daten von Instanzen dieser Klasse benötigen. Auch kann es Klassen und Variablen geben, bei denen es aus technischen Gründen nicht sinnvoll ist, mehr als eine Instanz anzulegen. Zu diesem Zweck können Deklarationen von Membervariablen und -funktionen mit dem Schlüsselwort static versehen werden. Es zeigt an, dass diese Variable oder Funktion ohne eine Instanz der Klasse existiert und benutzt werden kann. Dies stellt in objektorientierten Sprachen meist die häufigste Verwendung des Schlüsselwortes dar.

In C++, C# und Java wird das static-Schlüsselwort zu diesem Zweck verwendet, VB.Net setzt hingegen das Shared-Schlüsselwort (übersetzt: (mit anderen Klasseninstanzen) geteilt) für diesen Zweck ein, um eine kontextabhängige Bedeutung des Static-Schlüsselwortes zu vermeiden, nachdem dieses aus Kompatibilitätsgründen zu VB Classic bereits in der Bedeutung als Speicherklasse verwendet wird.

Statische Variablen und Methoden werden aufgrund ihres Zweckes ohne Klasseninstanz aufgerufen, so dass häufig auch keine Instanz zur Verfügung steht, über die man die Methode aufrufen könnte. Die übliche Syntax Variable.Methode() bzw. Variable->Methode() fällt daher weg. Um dennoch auf sie zugreifen zu können, ruft man die Methoden über den Namen der Klasse auf (Klasse.Methode() bzw. Klasse::Methode()). Um zu verhindern, dass der Programmierer die Auswirkung seiner Programmierung falsch einschätzt, ist in einigen Programmiersprachen der Aufruf eines statischen Klassenmembers über eine Instanz verboten oder es werden Kompilierwarnungen erzeugt.

//Header:
class C
{
public:
    int i;
    static int s;  // nur Deklaration!
};

//Source:
int C::s = 42; // Definition & Initialisierung der statischen Membervariablen

int usage()
{
    C::s = 1; // Benutzung ohne ein Objekt vom Typ C
    C c;
    c.i = 17;
    c.s = 0;  // möglich, aber Gefahr dass der Programmierer die Auswirkungen falsch einschätzt. Compiler kann hier warnen.
}

class Beispiel {
  public static int s; // statische Variable, Initialisierung im statischen Initializer.
  public static int t = 5; // statische Variable mit Standardwert
  public int i; // Klassenvariable, Initialisierung im Konstruktor
  public Beispiel() { // Konstruktor, Initialisierung von i im Konstruktor.
    i = 0;
  }
  static { //Statischer Initializer: Syntax in Java: nur ein static-Schlüsselwort
    s = 42; //Statischer Initializer, Initialisierung von s im statischen Initializer
  }
  public static void usage() {
    Beispiel.s += 1; //Aufruf über den Klassennamen
    Beispiel b = new Beispiel();
    b.i += 1; //Aufruf der Klassenvariable über eine Instanz.
    b.s += 1; // Keine Kompilierwarnung in Java.
  }
}

class Beispiel
{
  public static int s; // statische Variable, Initialisierung im statischen Konstruktor.
  public static int t = 5; // statische Variable mit Standardwert
  public int i; // Klassenvariable, Initialisierung im Konstruktor
  public Beispiel() // Konstruktor, Initialisierung von i im Konstruktor.
  {
    i = 0;
  }
  static Beispiel() // statischer Konstruktor: Syntax in C#: Konstruktor mit static-Schlüsselwort und ohne Parameter und Zugriffsmodifikator
  {
    s = 42; // Initialisierung von s im statischen Konstruktor
  }
  public static void Usage()
  {
    Beispiel.s += 1; // Aufruf über den Klassennamen
    Beispiel b = new Beispiel();
    b.i += 1; // Aufruf der Klassenvariable über eine Instanz.
    b.s += 1; // Erzeugt einen Kompilierfehler (CS0176), um Fehleinschätzungen zu vermeiden.
  }
}

Public Class Beispiel
  Public Shared s As Integer 'Statische Variable, Initialisierung im statischen Konstruktor.
  Public Shared t As Integer = 5 'Statische Variable mit Standardwert
  Public i As Integer 'Klassenvariable, Initialisierung im Konstruktor
  Public Sub New() 'Konstruktor, Initialisierung von i im Konstruktor.
    i = 0
  End Sub
  Shared Sub New() 'Statischer Konstruktor: Syntax in VB.Net: Konstruktor mit Shared-Schlüsselwort und ohne Parameter und Zugriffsmodifikator
    s = 42 'Statischer Konstruktor, Initialisierung von s im statischen Konstruktor
  End Sub
  Public Shared Sub Usage()
    Beispiel.s += 1 'Aufruf über den Klassennamen
    Dim b As New Beispiel()
    b.i += 1 'Aufruf der Klassenvariable über eine Instanz.
    b.s += 1 'Erzeugt eine Kompilierwarnung (BC42025), um Fehleinschätzungen zu vermeiden.
  End Sub
End Class

Da Arrays in C als „Zeiger auf das erste Element“ an Funktionen übergeben werden, ist der Funktion die Größe des Arrays nicht bekannt. In C99 wurde die Möglichkeit geschaffen, bei der Deklaration der Funktion eine Mindestgröße mitzugeben. Dies erlaubt zum einen eine bessere Typprüfung zur Kompilierzeit und – vor allem im Zusammenhang mit dem restrict-Schlüsselwort – die Erzeugung performanteren Codes.

Ähnliche Prüfungen können in VB.Net und in C# ab .Net 4.0 im Rahmen der weit mächtigeren Codeverträge durchgeführt werden. Die static-Syntax in der Signatur der Methode, wie in C, wird dabei jedoch nicht unterstützt. Auch in C++ wurde diese Bedeutung nicht übernommen.

Beispiel

void hash(unsigned char digest[static 64], const char* data, size_t size);

int main()
{
    unsigned char buffer[32];
    hash(buffer, data, length);  // Compilerwarnung: hash erwartet mind. 64 Bytes, buffer ist aber kleiner!
}

• static in C++, MSDN (englisch)
• static in C#, MSDN (deutsch)
• Shared in VB.Net, MSDN (deutsch)
• Static in VB.Net, MSDN (deutsch)
• Java Sprachspezifikation zu statischen Feldern, Methoden und statischen Initializern (englisch)

1. Peter Aitken: Preserve procedure variables with Static in VB6. techrepublic.com, 8. September 2005, abgerufen am 8. November 2019.