Anweisungen

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

C++ Sprache

Allgemeine Themen
Präprozessor Kommentare	Schlüsselwörter Escape-Sequenzen
Kontrollfluss
Bedingte Ausführungsaussagen
if	switch
Iterationsanweisungen (Schleifen)
for Bereichs-for (C++11)	while do-while
Sprunganweisungen
continue - break	goto - return
Funktionen
Funktionsdeklaration
Lambda-Funktionsausdruck
inline-Spezifizierer
Dynamische Ausnahmespezifikationen (bis C++17*)
noexcept-Spezifizierer (C++11)
Ausnahmen
throw-Ausdruck try-Block	catch-Handler
Namensräume
Namensdeklaration	Namensaliase
Typen
Fundamentale Typen Aufzählungstypen Funktionstypen	Klassen-/Strukturtypen Union-Typen
Spezifizierer
const/volatile decltype (C++11) auto (C++11)	constexpr (C++11) consteval (C++20) constinit (C++20)
Speicherdauer-Spezifizierer
Initialisierung
Standardinitialisierung Wertinitialisierung Nullinitialisierung Kopierinitialisierung Direkte Initialisierung	Aggregatinitialisierung Listeninitialisierung (C++11)   Konstante Initialisierung Referenzinitialisierung

Ausdrücke
Wertkategorien Reihenfolge der Auswertung	Operatoren Operatorrangfolge
Alternative Darstellungen
Literale
Boolesch - Ganzzahl - Gleitkommazahl
Zeichen - String - nullptr (C++11)
Benutzerdefinierte (C++11)
Dienstprogramme
Attribute (C++11)
Typen
typedef-Deklaration
Typalias-Deklaration (C++11)
Umwandlungen
Implizite Konvertierungen static_cast const_cast	Explizite Konvertierungen dynamic_cast reinterpret_cast
Speicherzuweisung
new-Ausdruck	delete-Ausdruck
Klassen
Klassendeklaration Konstruktoren this-Zeiger	Zugriffsspezifizierer friend-Spezifizierer
Klassenspezifische Funktionseigenschaften
Virtuelle Funktion override-Spezifizierer (C++11)   final-Spezifizierer (C++11)	explicit (C++11) static
Spezielle Member-Funktionen
Standardkonstruktor Kopierkonstruktor Move-Konstruktor (C++11)	Kopierzuweisung Move-Zuweisung (C++11) Destruktor
Templates
Klassenschablone Funktionsschablone	Schablonenspezialisierung Parameter-Pakete (C++11)
Sonstiges
Inline-Assembler	Geschichte von C++

 

Anweisungen

Labels

label : statement

Ausdrucksanweisungen

expression ;

Compound statements

{ Anweisung... }

Selektionsanweisungen

if

switch

Iterationsanweisungen

while

do while

for

Bereichs-for (C++11)

Sprunganweisungen

break

continue

return

goto

Assertions

contract_assert (C++26)

Deklarationsanweisungen

Deklaration ;

Try-Blöcke

try Block

Transaktionaler Speicher

synchronized, atomic_commit, etc. (TM TS)

 

Anweisungen sind Fragmente eines C++-Programms, die nacheinander ausgeführt werden. Der Körper jeder Funktion ist eine Sequenz von Anweisungen. Zum Beispiel

int main()
{
    int n = 1;                        // declaration statement
    n = n + 1;                        // expression statement
    std::cout << "n = " << n << '\n'; // expression statement
    return 0;                         // return statement
}

C++ enthält die folgenden Arten von Anweisungen

• Beschriftete Anweisungen
• Ausdrucksanweisungen
• Compound statements
• Selektionsanweisungen
• Iterationsanweisungen
• Sprunganweisungen

Assertion-Anweisungen

(seit C++26)

• Deklarationsanweisungen
• try-Blöcke

Atomare und synchronisierte Blöcke

(TM TS)

Beschriftete Anweisungen

Eine beschriftete Anweisung beschriftet eine Anweisung zu Kontrollflusszwecken.

Label-Anweisung

Label	-	Das Label, das auf die Anweisung angewendet wird (definiert unten)
Anweisung	-	Die Anweisung, auf die das Label angewendet wird; es kann selbst eine beschriftete Anweisung sein, was mehrere Labels ermöglicht.

Labels

Label ist definiert als

attr (optional) Bezeichner :	(1)
attr (optional) case constexpr :	(2)
attr (optional) default:	(3)

1) Ziel für goto;

2) case-Label in einer switch-Anweisung;

3) default-Label in einer switch-Anweisung.

Eine Attributsequenz attr kann entweder direkt am Anfang des Labels stehen (in diesem Fall bezieht sie sich auf das Label) oder direkt vor der Anweisung selbst, in diesem Fall bezieht sie sich auf die gesamte Anweisung.

(seit C++11)

Ein Label mit einem Bezeichner, der innerhalb einer Funktion deklariert wird, entspricht allen goto-Anweisungen mit demselben Bezeichner in dieser Funktion, in allen verschachtelten Blöcken, vor und nach seiner eigenen Deklaration.

Zwei Labels in einer Funktion dürfen nicht denselben Bezeichner haben.

Neben der Hinzufügung zu einer Anweisung können Labels auch überall in zusammengesetzten Anweisungen verwendet werden.

(seit C++23)

Labels werden nicht durch unqualifizierte Suche gefunden: Ein Label kann denselben Namen wie jede andere Entität im Programm haben.

void f()
{
    {
        goto label; // label in scope even though declared later
        label:      // label can appear at the end of a block standalone since C++23
    }
    goto label; // label ignores block scope
}
 
void g()
{
    goto label; // error: label not in scope in g()
}

Kontrollflussbeschränkte Anweisungen

Die folgenden Anweisungen sind kontrollflussbeschränkte Anweisungen 

• Die zusammengesetzte_Anweisung eines try-Blocks.
• Die zusammengesetzte_Anweisung eines Handlers.

Alle Unteranweisungen einer constexpr if-Anweisung.	(seit C++17)
Alle Unteranweisungen einer consteval if-Anweisung.	(seit C++23)

Für jede kontrollflussbeschränkte Anweisung S

• Alle in S deklarierten goto-Ziel-Labels können nur von Anweisungen in S referenziert werden.
• Jedes Label vom Typ case oder default, das innerhalb von S erscheint, kann nur mit einer switch-Anweisung innerhalb von S assoziiert werden.

Ausdrucksanweisungen

Eine Ausdrucksanweisung ist ein Ausdruck, gefolgt von einem Semikolon.

attr (optional) Ausdruck (optional) ;

attr	-	(seit C++11) optionale Sequenz beliebig vieler Attribute
expression	-	Ein Ausdruck

Die meisten Anweisungen in einem typischen C++-Programm sind Ausdrucksanweisungen, wie Zuweisungen oder Funktionsaufrufe.

Eine Ausdrucksanweisung ohne Ausdruck wird als Null-Anweisung bezeichnet. Sie wird oft verwendet, um einen leeren Körper für eine for- oder while-Schleife bereitzustellen. Sie kann auch verwendet werden, um ein Label am Ende einer zusammengesetzten Anweisung zu tragen.(bis C++23)

Zusammengesetzte Anweisungen

Eine zusammengesetzte Anweisung oder ein Block gruppiert eine Sequenz von Anweisungen zu einer einzigen Anweisung.

attr (optional) { Anweisung... (optional) Label... (optional)(seit C++23) }

Wenn eine einzelne Anweisung erwartet wird, aber mehrere Anweisungen nacheinander ausgeführt werden müssen (z. B. in einer if-Anweisung oder einer Schleife), kann eine zusammengesetzte Anweisung verwendet werden.

if (x > 5)          // start of if statement
{                   // start of block
    int n = 1;      // declaration statement
    std::cout << n; // expression statement
}                   // end of block, end of if statement

Jede zusammengesetzte Anweisung führt ihren eigenen Block- Gültigkeitsbereich ein; Variablen, die innerhalb eines Blocks deklariert werden, werden an der schließenden Klammer in umgekehrter Reihenfolge zerstört.

int main()
{ // start of outer block
    {                                // start of inner block
        std::ofstream f("test.txt"); // declaration statement
        f << "abc\n";                // expression statement
    }                                // end of inner block, f is flushed and closed
    std::ifstream f("test.txt"); // declaration statement
    std::string str;             // declaration statement
    f >> str;                    // expression statement
} // end of outer block, str is destroyed, f is closed

Ein Label am Ende einer zusammengesetzten Anweisung wird behandelt, als ob ihm eine Null-Anweisung folgen würde.

(seit C++23)

Selektionsanweisungen

Eine Selektionsanweisung wählt zwischen einem von mehreren Kontrollflüssen.

attr (optional) if constexpr(optional) ( init-statement (optional) Bedingung ) Anweisung	(1)
attr (optional) if constexpr(optional) ( init-statement (optional) Bedingung ) Anweisung     else Anweisung	(2)
attr (optional) switch ( init-statement (optional) Bedingung ) Anweisung	(3)
attr (optional) if !(optional) consteval zusammengesetzte_Anweisung	(4)	(seit C++23)
attr (optional) if !(optional) consteval zusammengesetzte_Anweisung else Anweisung	(5)	(seit C++23)

1) if-Anweisung;

2) if-Anweisung mit einem else-Zweig;

3) switch-Anweisung;

4) consteval if-Anweisung;

5) consteval if-Anweisung mit einem else-Zweig.

Iterationsanweisungen

Eine Iterationsanweisung wiederholt die Ausführung eines Codes.

attr (optional) while ( Bedingung ) Anweisung	(1)
attr (optional) do Anweisung while ( Ausdruck ) ;	(2)
attr (optional) for ( init-statement Bedingung (optional) ; Ausdruck (optional) ) Anweisung	(3)
attr (optional) for     ( init-statement (optional)(seit C++20) for-range-decl : for-range-init ) Anweisung	(4)	(seit C++11)

1) while-Schleife;

2) do-while-Schleife;

3) for-Schleife;

4) Bereichs-for-Schleife.

Sprunganweisungen

Eine Sprunganweisung überträgt den Kontrollfluss bedingungslos.

attr (optional) break;	(1)
attr (optional) continue;	(2)
attr (optional) return Ausdruck (optional) ;	(3)
attr (optional) return braced-init-list ;	(4)	(seit C++11)
attr (optional) goto Bezeichner ;	(5)

1) break-Anweisung;

2) continue-Anweisung;

3) return-Anweisung mit optionalem Ausdruck;

4) return-Anweisung mit List-Initialisierung;

5) goto-Anweisung.

Hinweis: Bei allen Sprunganweisungen führt der Transfer aus einer Schleife, aus einem Block oder zurück über eine initialisierte Variable mit automatischer Speicherdauer zur Zerstörung von Objekten mit automatischer Speicherdauer, die an der Stelle des Transfers im Gültigkeitsbereich liegen, aber nicht an der Zielstelle. Wenn mehrere Objekte initialisiert wurden, ist die Reihenfolge der Zerstörung die umgekehrte Reihenfolge der Initialisierung.

Assertion-Anweisungen Eine Vertrags-Assertion. contract_assert attr (optional) ( Prädikat ) ; 1) contract_assert-Anweisung.

(seit C++26)

Deklarationsanweisungen

Eine Deklarationsanweisung führt einen oder mehrere Bezeichner in einen Block ein.

Block-Deklaration	(1)

1) Siehe Deklarationen und Initialisierung für Details.

try-Blöcke

Ein try-Block fängt Ausnahmen ab, die beim Ausführen anderer Anweisungen ausgelöst werden.

attr (optional) try zusammengesetzte_Anweisung Handler-Sequenz	(1)

1) Siehe try-Block für Details.

Atomare und synchronisierte Blöcke Ein atomarer und synchronisierter Block bietet transaktionalen Speicher. synchronized zusammengesetzte_Anweisung (1) (TM TS) atomic_noexcept zusammengesetzte_Anweisung (2) (TM TS) atomic_cancel zusammengesetzte_Anweisung (3) (TM TS) atomic_commit zusammengesetzte_Anweisung (4) (TM TS) 1) synchronisierter Block, ausgeführt in totaler Einzelreihenfolge mit allen synchronisierten Blöcken; 2) atomarer Block, der bei Ausnahmen abbricht; 3) atomarer Block, der bei Ausnahmen zurückrollt; 4) atomarer Block, der bei Ausnahmen committet.

(TM TS)

Unteranweisungen

Eine Unteranweisung einer Anweisung ist eine der folgenden:

• Für eine beschriftete Anweisung ihre Anweisung .
• Für eine zusammengesetzte Anweisung jede Anweisung ihrer Anweisung... .
• Für eine Selektionsanweisung eine beliebige ihrer Anweisung  oder zusammengesetzte_Anweisung (seit C++23).
• Für eine Iterationsanweisung ihre Anweisung .

Eine Anweisung S1 umschließt eine Anweisung S2, wenn eine der folgenden Bedingungen erfüllt ist:

• S2 ist eine Unteranweisung von S1.
• S1 ist eine Selektions- oder Iterationsanweisung, und S2 ist die init-statement von S1.
• S1 ist ein try-Block und S2 ist entweder seine zusammengesetzte_Anweisung oder die zusammengesetzte_Anweisung eines beliebigen Handlers in seiner handler-seq .
• S1 umschließt eine Anweisung S3 und S3 umschließt S2.

Eine Anweisung S1 wird von einer Anweisung S2 umschlossen, wenn S2 S1 umschließt.

Siehe auch

C-Dokumentation für Anweisungen