static members

• 1 Syntax
• 2 Erklärung
  • 2.1 Statische Memberfunktionen
  • 2.2 Statische Datenelemente
  • 2.3 Konstante statische Member
• 3 Schlüsselwörter
• 4 Fehlerberichte
• 5 Referenzen
• 6 Siehe auch

Syntax

Eine Deklaration für einen static‑Member ist eine Member-Deklaration, deren Deklarationsspezifizierer das Schlüsselwort static enthalten. Das Schlüsselwort static erscheint normalerweise vor anderen Spezifizierern (weshalb die Syntax oft informell als static member-declaration beschrieben wird), kann aber an jeder Stelle in der Spezifizierer-Sequenz auftreten.

Der Name jedes static‑Daten‑Members und jeder static‑Member‑Funktion muss vom Namen der enthaltenden Klasse verschieden sein.

Erklärung

Statische Member einer Klasse sind nicht mit den Objekten der Klasse assoziiert: Sie sind unabhängige Variablen mit statischer oder Thread- (seit C++11) Speicherdauer oder reguläre Funktionen.

Das static Schlüsselwort wird nur bei der Deklaration eines statischen Members innerhalb der Klassendefinition verwendet, jedoch nicht bei der Definition dieses statischen Members:

class X { static int n; }; // Deklaration (verwendet 'static')
int X::n = 1;              // Definition (verwendet kein 'static')

Die Deklaration innerhalb des Klassenkörpers ist keine Definition und kann das Mitglied als unvollständigen Typ (außer void ) deklarieren, einschließlich des Typs, in dem das Mitglied deklariert wird:

struct Foo;
struct S
{
    static int a[]; // Deklaration, unvollständiger Typ
    static Foo x;   // Deklaration, unvollständiger Typ
    static S s;     // Deklaration, unvollständiger Typ (innerhalb der eigenen Definition)
};
int S::a[10]; // Definition, vollständiger Typ
struct Foo {};
Foo S::x;     // Definition, vollständiger Typ
S S::s;       // Definition, vollständiger Typ

Um auf ein statisches Mitglied m der Klasse T zu verweisen, können zwei Formen verwendet werden: qualifizierter Name T::m oder Mitgliedszugriffsausdruck E.m oder E->m , wobei E ein Ausdruck ist, der zu T oder T* ausgewertet wird. Wenn im selben Klassenbereich, ist die Qualifizierung nicht erforderlich:

struct X
{
    static void f(); // Deklaration
    static int n;    // Deklaration
};
X g() { return X(); } // eine Funktion, die X zurückgibt
void f()
{
    X::f();  // X::f ist ein qualifizierter Name einer statischen Memberfunktion
    g().f(); // g().f ist ein Memberzugriffsausdruck, der auf eine statische Memberfunktion verweist
}
int X::n = 7; // Definition
void X::f() // Definition
{
    n = 1; // X::n ist in diesem Gültigkeitsbereich als n zugänglich
}

Statische Member befolgen die Klassenmember-Zugriffsregeln (private, protected, public) .

Statische Memberfunktionen

Statische Memberfunktionen sind mit keinem Objekt verbunden. Beim Aufruf haben sie keinen this -Zeiger.

Statische Memberfunktionen können nicht virtual , const , volatile oder ref-qualified sein.

Die Adresse eines statischen Member-Funktion kann in einem regulären Zeiger auf Funktion gespeichert werden, aber nicht in einem Zeiger auf Member-Funktion .

Statische Datenelemente

Statische Datenelemente sind keinem Objekt zugeordnet. Sie existieren, auch wenn keine Objekte der Klasse definiert wurden. Es gibt nur eine Instanz des statischen Datenelements im gesamten Programm mit statischer Speicherdauer, es sei denn, das Schlüsselwort thread_local wird verwendet, in diesem Fall gibt es ein solches Objekt pro Thread mit Thread-Speicherdauer(seit C++11).

Statische Datenelemente können nicht mutable sein.

Statische Datenelemente einer Klasse im Gültigkeitsbereich eines Namensraums haben externe Bindung, wenn die Klasse selbst eine externe Bindung hat (kein Mitglied eines unbenannten Namensraums ist). Lokale Klassen (innerhalb von Funktionen definierte Klassen) und unbenannte Klassen, einschließlich Mitgliedsklassen unbenannter Klassen, können keine statischen Datenelemente haben.

struct X
{
    inline static int fully_usable = 1; // No out-of-class definition required,
                                        // ODR-usable
    inline static const std::string class_name{"X"}; // Likewise

    static const int non_addressable = 1; // C.f. non-inline constants, usable
                                          // for its value, but not ODR-usable
    // static const std::string class_name{"X"}; // Non-integral declaration of this
                                                 // form is disallowed entirely
};

Konstante statische Member

Wenn ein statisches Datenelement vom integralen oder Aufzählungstyp als const (und nicht volatile ) deklariert wird, kann es mit einem Initialisierer initialisiert werden, in dem jeder Ausdruck ein konstanter Ausdruck ist, direkt innerhalb der Klassendefinition:

struct X
{
    const static int n = 1;
    const static int m{2}; // seit C++11
    const static int k;
};
const int X::k = 3;

struct X
{
    constexpr static int arr[] = { 1, 2, 3 };        // OK
    constexpr static std::complex<double> n = {1,2}; // OK
    constexpr static int k; // Error: constexpr static requires an initializer
};

Wenn ein const non-inline (since C++17) static data member oder ein constexpr static data member (since C++11) (until C++17) ODR-used wird, ist weiterhin eine Definition im Namespace-Bereich erforderlich, sie darf jedoch keinen Initialisierer haben.

struct X
{
    static const int n = 1;
    static constexpr int m = 4;
};
const int *p = &X::n, *q = &X::m; // X::n und X::m werden ODR-verwendet
const int X::n;             // … daher ist eine Definition erforderlich
constexpr int X::m;         // … (außer für X::m in C++17)

Schlüsselwörter

static

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen

Siehe auch

• static Speicherdauer-Spezifizierer