Declarations

Deklarationen sind die Art und Weise, wie Namen in das C++-Programm eingeführt (oder wieder eingeführt) werden. Nicht alle Deklarationen deklarieren tatsächlich etwas, und jede Art von Entität wird unterschiedlich deklariert. Definitionen sind Deklarationen, die ausreichen, um die durch den Namen identifizierte Entität zu verwenden.

Eine Deklaration ist eines der folgenden Elemente:

• Funktionsdefinition
• Template-Deklaration (einschließlich Partielle Template-Spezialisierung )
• Explizite Template-Instanziierung
• Explizite Template-Spezialisierung
• Namespace-Definition
• Linkage-Spezifikation

• Leere Deklaration ( ; )
• Eine Funktionsdeklaration ohne decl-specifier-seq :

Diese Deklaration muss einen Konstruktor, Destruktor oder eine benutzerdefinierte Konvertierungsfunktion deklarieren. Sie kann nur als Teil einer Template-Deklaration , expliziten Spezialisierung oder expliziten Instanziierung verwendet werden.

• block-declaration (eine Deklaration, die innerhalb eines Blocks erscheinen kann), die wiederum eine der folgenden sein kann:

• asm-Deklaration

• Namespace-Alias-Definition
• using-Deklaration
• using-Direktive

• einfache Deklaration

Einfache Deklaration

Eine einfache Deklaration ist eine Anweisung, die einen oder mehrere Bezeichner, typischerweise Variablen, einführt, erstellt und optional initialisiert.

init-declarator-list kann nur beim Deklarieren einer benannten Klasse oder einer benannten Enumeration weggelassen werden.

Die Syntax von init-declarator ist wie folgt definiert:

Spezifizierer

Deklarationsspezifizierer ( decl-specifier-seq ) ist eine Sequenz der folgenden, durch Leerzeichen getrennten Spezifizierer in beliebiger Reihenfolge:

• der typedef -Spezifizierer. Falls vorhanden, ist die gesamte Deklaration eine Typdeklaration und jeder Deklarator führt einen neuen Typnamen ein, kein Objekt oder eine Funktion.
• Funktionsspezifizierer ( inline , virtual , explicit ), nur erlaubt in Funktionsdeklarationen .

• der friend Spezifizierer, erlaubt in Klassen- und Funktionsdeklarationen.

• Speicherklassenspezifizierer ( register , (bis C++17) static , thread_local , (seit C++11) extern , mutable ). Nur ein Speicherklassenspezifizierer ist erlaubt , außer dass thread_local zusammen mit extern oder static auftreten darf (seit C++11) .
• Typspezifizierer ( type-specifier-seq ), eine Sequenz von Spezifizierern, die einen Typ benennt. Der Typ jeder durch die Deklaration eingeführten Entität ist dieser Typ, optional modifiziert durch den Deklarator (siehe unten). Diese Sequenz von Spezifizierern wird auch von type-id verwendet. Nur die folgenden Spezifizierer sind Teil von type-specifier-seq , in beliebiger Reihenfolge:

• Klassenspezifizierer
• Aufzählungsspezifizierer
• Einfacher Typspezifizierer

• char , char8_t , (seit C++20) char16_t , char32_t , (seit C++11) wchar_t , bool , short , int , long , signed , unsigned , float , double , void

• zuvor deklarierter Klassenname (optional qualifiziert )
• zuvor deklarierter Enum-Name (optional qualifiziert )
• zuvor deklarierter typedef-name oder type alias (seit C++11) (optional qualifiziert )
• Template-Name mit Template-Argumenten (optional qualifiziert , optional unter Verwendung des template disambiguator )

• elaborated type specifier

• das Schlüsselwort class , struct , oder union , gefolgt vom Bezeichner (optional qualifiziert ), der zuvor als Name einer Klasse definiert wurde.
• das Schlüsselwort class , struct , oder union , gefolgt vom Template-Namen mit Template-Argumenten (optional qualifiziert , optional unter Verwendung des template Disambiguators ), der zuvor als Name eines Klassentemplates definiert wurde.
• das Schlüsselwort enum gefolgt vom Bezeichner (optional qualifiziert ), der zuvor als Name einer Enumeration deklariert wurde.

• typename Specifier
• cv-Qualifizierer

nur ein Typ-Spezifizierer ist in einer decl-specifier-seq erlaubt, mit folgenden Ausnahmen:

• const kann mit jedem Typ-Spezifizierer kombiniert werden, außer mit sich selbst.
• volatile kann mit jedem Typ-Spezifizierer kombiniert werden, außer mit sich selbst.
• signed oder unsigned kann kombiniert werden mit char , long , short , oder int .
• short oder long kann kombiniert werden mit int .
• long kann kombiniert werden mit double .

Attribute können in decl-specifier-seq erscheinen, in welchem Fall sie auf den durch die vorhergehenden Spezifizierer bestimmten Typ angewendet werden.

Wiederholungen jeglicher Spezifizierer in einer decl-specifier-seq , wie const static const oder virtual inline virtual sind Fehler , außer dass long zweimal auftreten darf (seit C++11) .

Deklaratoren

Jeder init-declarator in einer init-declarator-list S D1, D2, D3 ; wird so verarbeitet, als wäre es eine eigenständige Deklaration mit denselben Spezifizierern: S D1 ; S D2 ; S D3 ; .

Jeder Deklarator führt genau ein Objekt, eine Referenz, eine Funktion oder (für typedef-Deklarationen) einen Typalias ein, dessen Typ durch die decl-specifier-seq bereitgestellt und optional durch Operatoren wie & (Referenz auf) oder [ ] (Array von) oder ( ) (Funktion zurückgebend) im Deklarator modifiziert wird. Diese Operatoren können rekursiv angewendet werden, wie unten gezeigt.

Ein Deklarator ist einer der folgenden:

cv ist eine Sequenz von const- und volatile Qualifizierern, wobei jeder Qualifizierer höchstens einmal in der Sequenz vorkommen darf.

Hinweise

Wenn eine block-declaration innerhalb eines Blocks erscheint und ein durch eine Deklaration eingeführter Bezeichner zuvor in einem äußeren Block deklariert wurde, wird die äußere Deklaration für den Rest des Blocks verborgen.

Wenn eine Deklaration eine Variable mit automatischer Speicherdauer einführt, wird sie initialisiert, wenn ihre Deklarationsanweisung ausgeführt wird. Alle automatischen Variablen, die in einem Block deklariert werden, werden beim Verlassen des Blocks zerstört (unabhängig davon, wie der Block verlassen wird: via exception , goto , oder durch Erreichen seines Endes), in umgekehrter Reihenfolge ihrer Initialisierung.

Beispiel

#include <type_traits>
struct S
{
    int member;
    // decl-specifier-seq is "int"
    // declarator is "member"
{ obj, *pObj(&obj);
// decl-specifier-seq is "struct S { int member; }"
// declarator "obj" declares an object of type S
// declarator "*pObj" declares a pointer to S,
//     and initializer "(&obj)" initializes it
int i = 1, *p = nullptr, f(), (*pf)(double);
// decl-specifier-seq is "int"
// declarator "i" declares a variable of type int,
//     and initializer "= 1" initializes it
// declarator "*p" declares a variable of type int*,
//     and initializer "= nullptr" initializes it
// declarator "f()" declares (but doesn't define)
//     a function taking no arguments and returning int
// declarator "(*pf)(double)" declares a pointer to function
//     taking double and returning int
int (*(*var1)(double))[3] = nullptr;
// decl-specifier-seq is "int"
// declarator is "(*(*var1)(double))[3]"
// initializer is "= nullptr"
// 1. declarator "(*(*var1)(double))[3]" is an array declarator:
//    Type declared is: "(*(*var1)(double))" array of 3 elements
// 2. declarator "(*(*var1)(double))" is a pointer declarator:
//    Type declared is: "(*var1)(double)" pointer to array of 3 elements
// 3. declarator "(*var1)(double)" is a function declarator:
//    Type declared is: "(*var1)" function taking "(double)",
//    returning pointer to array of 3 elements.
// 4. declarator "(*var1)" is a pointer declarator:
//    Type declared is: "var1" pointer to function taking "(double)",
//    returning pointer to array of 3 elements.
// 5. declarator "var1" is an identifier.
// This declaration declares the object var1 of type "pointer to function
// taking double and returning pointer to array of 3 elements of type int"
// The initializer "= nullptr" provides the initial value of this pointer.
// C++11 alternative syntax:
auto (*var2)(double) -> int (*)[3] = nullptr;
// decl-specifier-seq is "auto"
// declarator is "(*var2)(double) -> int (*)[3]"
// initializer is "= nullptr"
// 1. declarator "(*var2)(double) -> int (*)[3]" is a function declarator:
//    Type declared is: "(*var2)" function taking "(double)", returning "int (*)[3]"
// ...
int main()
{
    static_assert(std::is_same_v<decltype(var1), decltype(var2)>);
}

Fehlerberichte

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

Siehe auch