Storage class specifiers

Die Speicherklassenspezifizierer sind ein Teil der decl-specifier-seq der Deklarationssyntax eines Namens. Zusammen mit dem Gültigkeitsbereich des Namens steuern sie zwei unabhängige Eigenschaften des Namens: seine Speicherdauer und seine Bindung .

Speicherdauer

Die storage duration ist die Eigenschaft eines Objekts , die die minimale potenzielle Lebensdauer des Speichers definiert, der das Objekt enthält. Die Speicherdauer wird durch das Konstrukt bestimmt, das zur Erstellung des Objekts verwendet wird, und ist eine der folgenden:

• statische Speicherdauer

• automatische Speicherdauer
• dynamische Speicherdauer

Static , Thread- (seit C++11) und automatische Speicherdauern sind mit Objekten verbunden, die durch Deklarationen eingeführt werden, sowie mit temporären Objekten . Die dynamische Speicherdauer ist mit Objekten verbunden, die durch einen new -Ausdruck erstellt werden, oder mit implizit erzeugten Objekten .

Die Speicherdauerkategorien gelten auch für Referenzen.

Die Speicherdauer von Subobjects und Referenzmitgliedern ist die ihres vollständigen Objekts.

Spezifizierer

Die folgenden Schlüsselwörter sind storage class specifiers :

• static

• extern
• mutable

In einer Dekl-Spezifizierer-Sequenz kann es höchstens einen Speicherklassen-Spezifizierer geben , außer dass thread_local zusammen mit static oder extern (seit C++11) vorkommen kann.

mutable hat keine Auswirkung auf die Speicherdauer. Für die Verwendung siehe const/volatile .

Andere Speicherklassenspezifizierer können in den decl-specifier-seq s der folgenden Deklarationen erscheinen:

Anonyme Unions können auch mit static deklariert werden.

Statische Speicherdauer

Eine Variable, die alle folgenden Bedingungen erfüllt, hat static storage duration :

• Es gehört zu einem Namensbereich (namespace scope) oder wird erstmals mit static oder extern deklariert.

Der Speicher für diese Entitäten besteht für die Dauer des Programms.

Automatische Speicherdauer

Die folgenden Variablen haben automatic storage duration :

• Variablen, die zu einem Blockbereich gehören und nicht explizit als static , thread_local , (since C++11) oder extern deklariert sind. Die Speicherdauer solcher Variablen besteht, bis der Block, in dem sie erzeugt wurden, verlassen wird.
• Variablen, die zu einem Parameterbereich gehören (d.h. Funktionsparameter). Die Speicherdauer eines Funktionsparameters besteht bis unmittelbar nach seiner Zerstörung .

Dynamische Speicherdauer

Objekte, die durch die folgenden Methoden während der Programmausführung erstellt werden, haben dynamic storage duration :

• new Ausdrücke . Der Speicher für solche Objekte wird durch Allokierungsfunktionen bereitgestellt und durch Deallokierungsfunktionen freigegeben.
• Implizite Erzeugung durch andere Mittel. Der Speicher für solche Objekte überlappt mit bestehendem Speicher.
• Ausnahmeobjekte . Der Speicher für solche Objekte wird auf nicht spezifizierte Weise allokiert und deallokiert.

Verknüpfung

Ein Name kann external linkage  , module linkage (since C++20) , internal linkage , oder no linkage haben:

• Eine Entität, deren Name externe Verknüpfung hat, kann in einer anderen Übersetzungseinheit neu deklariert werden , und die Neudeklaration kann einem anderen Modul zugeordnet werden (seit C++20) .

• Eine Entität, deren Name interne Verknüpfung hat, kann in einem anderen Gültigkeitsbereich in derselben Übersetzungseinheit erneut deklariert werden.
• Eine Entität, deren Name keine Verknüpfung hat, kann nur im selben Gültigkeitsbereich erneut deklariert werden.

Die folgenden Verknüpfungen werden erkannt:

Keine Verknüpfung

Jeder der folgenden Namen, die im Blockbereich deklariert werden, hat keine Bindung:

• Variablen, die nicht explizit deklariert sind extern (unabhängig vom static Modifikator);
• lokale Klassen und ihre Memberfunktionen;
• Andere Namen, die im Blockbereich deklariert sind, wie Typdefinitionen, Enumerationen und Enumeratoren.

Nicht mit externer , Modul-, (seit C++20) oder interner Verknüpfung spezifizierte Namen haben ebenfalls keine Verknüpfung, unabhängig davon, in welchem Geltungsbereich sie deklariert sind.

Interne Verknüpfung

Jeder der folgenden Namen, die im Namespace-Bereich deklariert sind, hat interne Verknüpfung:

• Variablen , Variablentemplates (since C++14) , Funktionen oder Funktionstemplates, die als static deklariert sind;
• Nicht-Template (since C++14) Variablen von nicht-flüchtigem const-qualifiziertem Typ, es sei denn

• sie sind explizit als extern deklariert, oder
• sie wurden zuvor deklariert und die vorherige Deklaration hatte keine interne Verknüpfung;

• Datenelemente von anonymen Unions .

Externe Verknüpfung

Variablen und Funktionen mit externer Verknüpfung haben ebenfalls Sprachverknüpfung , was das Verknüpfen von Übersetzungseinheiten ermöglicht, die in verschiedenen Programmiersprachen geschrieben sind.

Jeder der folgenden Namen, die im Namespace-Bereich deklariert sind, besitzt externe Verknüpfung, es sei denn, sie sind in einem unbenannten Namespace deklariert oder ihre Deklarationen sind an ein benanntes Modul angehängt und nicht exportiert (seit C++20) :

• Variablen und Funktionen, die nicht oben aufgeführt sind (d.h. Funktionen, die nicht als static deklariert sind, nicht-konstante Variablen, die nicht als static deklariert sind, und alle Variablen, die als extern deklariert sind);
• Enumerationen;
• Namen von Klassen, deren Memberfunktionen, statischen Datenelementen (const oder nicht), geschachtelten Klassen und Enumerationen, sowie Funktionen, die erstmals durch friend -Deklarationen innerhalb von Klassenkörpern eingeführt werden;
• Namen aller Templates, die nicht oben aufgeführt sind (d.h. keine Funktions-Templates, die als static deklariert sind).

Jeder der folgenden Namen, der zuerst im Blockbereich deklariert wird, hat externe Verknüpfung:

• Namen von Variablen, die als extern deklariert sind;
• Namen von Funktionen.

Statische Blockvariablen

Blockvariablen mit statischer oder Thread- (seit C++11) Speicherdauer werden initialisiert, wenn die Ausführung zum ersten Mal ihre Deklaration durchläuft (sofern ihre Initialisierung nicht Null- oder Konstanteninitialisierung ist, die bereits vor dem ersten Betreten des Blocks durchgeführt werden kann). Bei allen weiteren Aufrufen wird die Deklaration übersprungen.

• Wenn die Initialisierung eine Exception wirft , wird die Variable nicht als initialisiert betrachtet, und die Initialisierung wird beim nächsten Durchlauf der Deklaration erneut versucht.
• Wenn die Initialisierung rekursiv in den Block eintritt, in dem die Variable initialisiert wird, ist das Verhalten undefiniert.

Der Destruktor für eine Blockvariable mit statischer Speicherdauer wird beim Programmende aufgerufen , aber nur wenn die Initialisierung erfolgreich stattgefunden hat.

Variablen mit statischer Speicherdauer in allen Definitionen derselben Inline-Funktion (die implizit inline sein kann) verweisen alle auf dasselbe Objekt, das in einer Übersetzungseinheit definiert ist, sofern die Funktion externe Verknüpfung besitzt.

Übersetzungseinheiten-lokale Entitäten

Das Konzept der übersetzungseinheitslokalen Entitäten wurde in C++20 standardisiert, siehe diese Seite für weitere Details.

Eine Entität ist translation-unit-local (oder kurz TU-local ), wenn

• es hat einen Namen mit interner Verknüpfung, oder
• es hat keinen Namen mit Verknüpfung und wird innerhalb der Definition einer TU-lokalen Entität eingeführt, oder
• es ist eine Template oder Template-Spezialisierung, deren Template-Argument oder Template-Deklaration eine TU-lokale Entität verwendet.

Schlechte Dinge (in der Regel Verletzung der ODR ) können passieren, wenn der Typ einer nicht-TU-lokalen Entität von einer TU-lokalen Entität abhängt, oder wenn eine Deklaration , oder ein deduction guide für, (since C++17) einer nicht-TU-lokalen Entität eine TU-lokale Entität außerhalb ihrer

• Funktionskörper für eine nicht-inline Funktion oder Funktionsvorlage
• Initialisierer für eine Variable oder Variablenvorlage
• Friend-Deklarationen in einer Klassendefinition
• Verwendung des Werts einer Variable, wenn die Variable in konstanten Ausdrücken verwendbar ist

Hinweise

Namen im obersten Namensraumbereich (Dateibereich in C), die const und nicht extern sind, haben externe Bindung in C, aber interne Bindung in C++.

Seit C++11 ist auto kein Speicherklassenspezifizierer mehr; es wird zur Typableitung verwendet.

Namen von thread_local Variablen mit interner oder externer Verknüpfung, auf die von verschiedenen Gültigkeitsbereichen aus verwiesen wird, können auf dieselben oder auf verschiedene Instanzen verweisen, abhängig davon, ob der Code im selben oder in verschiedenen Threads ausgeführt wird.

Das extern Schlüsselwort kann auch verwendet werden, um Sprachverknüpfung und explizite Template-Instanziierungsdeklarationen anzugeben, aber es ist in diesen Fällen kein Speicherklassenspezifizierer (außer wenn eine Deklaration direkt in einer Sprachverknüpfungsspezifikation enthalten ist, in welchem Fall die Deklaration so behandelt wird, als ob sie den extern Spezifizierer enthielte).

Speicherklassenspezifizierer, mit Ausnahme von thread_local , sind nicht zulässig bei expliziten Spezialisierungen und expliziten Instanziierungen :

template<class T>
struct S
{
    thread_local static int tlm;
};
template<>
thread_local int S<float>::tlm = 0; // "static" erscheint hier nicht

Schlüsselwörter

auto , register , static , extern , thread_local , mutable

Beispiel

#include <iostream>
#include <mutex>
#include <string>
#include <thread>
thread_local unsigned int rage = 1;
std::mutex cout_mutex;
void increase_rage(const std::string& thread_name)
{
    ++rage; // modifying outside a lock is okay; this is a thread-local variable
    std::lock_guard<std::mutex> lock(cout_mutex);
    std::cout << "Rage counter for " << thread_name << ": " << rage << '\n';
}
int main()
{
    std::thread a(increase_rage, "a"), b(increase_rage, "b");
    {
        std::lock_guard<std::mutex> lock(cout_mutex);
        std::cout << "Rage counter for main: " << rage << '\n';
    }
    a.join();
    b.join();
}

Rage counter for a: 2
Rage counter for main: 1
Rage counter for b: 2

Fehlerberichte

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

Referenzen

Siehe auch