Die Verbundanweisung in C++

Eine Verbundanweisung besteht aus einem Paar geschweifter Klammern, in denen eine Folge von Anweisungen enthalten sein kann.

Zwischen den geschweiften Klammern »{« und »}« dürfen auch mehrere Anweisungen stehen, die dann in der Reihenfolge, in der sie im Quelltext stehen, zeitlich hintereinander ausgeführt werden.

Eine Verbundanweisung ist ebenfalls eine Anweisung.

Verbundanweisung (Beispiel)

{ ::std::putchar( 65 ); ::std::putchar( 66 ); }

Verbundanweisung (Syntaxdiagramm)

Anweisung
      .-.                                   .-.
---->( { )----.----------------------.---->( } )---->
      '-'     |                      |      '-'
              |    .-----------.     |
              '----| Anweisung |<----'
                   '-----------'

Die Verbundanweisung, die auch Block genannt wird, enthält eine Folge von Anweisungen in geschweiften Klammern. Bei der Ausführung der Verbundanweisung werden diese enthaltenen Anweisungen in der gegebenen Reihenfolge ausgeführt.

Im folgenden sieht man eine Verbundanweisung im Zusammenhang eines vollständigen Programmes.

main.cpp

#include <cstdio> /* ::std::putchar */
int main()
/* Verbundanweisung: */
{ ::std::putchar( 86 ); 
  ::std::putchar( 87 ); 
  ::std::cout << "\n"s; }

::std::cout

VW

Operationssequenz

::std::putchar( 86 ) → Ausgabe von V → 86

::std::putchar( 87 ) → Ausgabe von W → 87

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
using namespace ::std::literals;
int main()
{ ::std::cout << 86 << "\n"s; 
  ::std::cout << 87 << "\n"s; }

::std::cout

86
87

Operationssequenz

::std::cout << 86 → Ausgabe von 86 → ::std::cout

::std::cout << "\n"s → Ausgabe eines Zeilenendes → ::std::cout

::std::cout << 87 → Ausgabe von 87 → ::std::cout

::std::cout << "\n"s → Ausgabe eines Zeilenendes → ::std::cout

Das folgende Beispielprogramm gibt das Schriftzeichen »V« und ein Zeilenende aus.

main.cpp

#include <iostream> /* ::std::cout     */
#include <ostream>  /* <<              */
#include <cstdio>   /* ::std::putchar  */
int main()
{ ::std::putchar( 86 ); 
  ::std::cout << "\n"s; }

::std::cout

Die Verbundanweisung ist eine Anweisung und kann selber Anweisungen enthalten (miteinander verbinden). Daher kann auch eine Verbundanweisung in einer Verbundanweisung enthalten sein. In dem folgenden Programmbeispiel bewirkt dies aber sonst nichts weiter – die inneren geschweiften Klammern könnten also genauso gut gelöscht werden.

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
using namespace ::std::literals;
int main()
{ ::std::cout << 86 << "\n"s; 
  { ::std::cout << 87 << "\n"s; }}

::std::cout

86
87

Das Semikolon steht nicht zwischen zwei Auswertungsanweisungen, sondern es ist Teil einer Auswertungsanweisug. Die Aufrufanweisungen stehen im Quelltext direkt hintereinander (abgesehen von optionalem Leerraum zwischen ihnen).

Die in einer Verbundanweisung im Quelltext direkt aufeinanderfolgenden Anweisungen werden bei der Ausführung der Verbundanweisung zeitlich hintereinander in derselben Reihenfolge ausgeführt, in der sie auch im Quelltext stehen. Dabei überlappen sich die Ausführungen zeitlich nicht: Die Ausführung der nächsten Anweisung wird also erst nach Beendigung einer Anweisung begonnen.

Im Zuge der Ausführung des ersten Aufrufausdrucks »::std::putchar( 87 )« in Zeile 4 wird die Kontrolle an die Operation »::std::putchar( 87 )« übergeben. Am Ende dieser Operation, kehrt die Kontrolle wieder zurück, woraufhin dann die nächste zur Ausführung anstehende Operation in Zeile 5 gestartet wird.

Das Aufrufgeschehen (Kompaßdiagramm)

.--------------------------------------------. int main()
| main                                       | {
|                                            | 
|    Zeit                                    |
|     |                                      |
|     |       .----------------------.       |
|     |       | ::std::putchar( 86 ) |       |     ::std::putchar( 86 );
|     |       '----------------------'       |
|     |                   |                  |
|     |                   V                  |
|     |            Ausgabe von "V"           |
|     |                                      |
|     |                                      |
|     |       .----------------------.       |
|     |       | ::std::putchar( 86 ) |       |     ::std::putchar( 86 );
|     |       '----------------------'       |
|     |                   |                  |
|     |                   V                  |
|     |            Ausgabe von "V"           |
|     |                                      |
|     V                                      |
|                                            |     }
'--------------------------------------------'
                     |
                     V
             Ausgabe zweier V

main.cpp

#include <iostream>
#include <ostream>
#include <string>   // ""s
using namespace ::std::literals;
int main()
{ ::std::cout << "Hallo, "s;
  ::std::cout << "Welt"s << "\n"s; }

::std::cout

Hallo, Welt

Operationssequenz

::std::cout << "Hallo, " → Ausgabe von "Hallo, " → ::std::cout

::std::cout << "Welt" → Ausgabe von "Welt" → ::std::cout

::std::cout << "\n"s → Ausgabe eines Zeilenendes → ::std::cout

»`int main()`« und die Verbundanweisung

Hinter »int main()« muß eine Verbundanweisung stehen.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
using namespace ::std::literals;
int main()
/* Es folgt eine Verbundanweisung: */
{ ::std::cout << 86 << "\n"s; 
  ::std::cout << 87 << "\n"s; }

::std::cout

86
87

Kennzahlen und Zeichen

Das folgende Programm gibt nur unter einigen Implementationen »vw« aus, da die Kennzahl »86« nicht unter allen Implementationen für das Schriftzeichen »v« steht.

main.cpp

#include <cstdio> /* ::std::putchar */
int main()
{ ::std::putchar( 86 ); 
  ::std::putchar( 87 ); 
  ::std::cout << "\n"s; }

::std::cout

VW

Um »vw« auszugeben, ist es sicherer, wenn die Schriftzeichen – und nicht die Kennzahlen – im Quelltext stehen.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
using namespace ::std::literals;
int main()
{ ::std::cout << "VW\n"s; }

Protokoll

VW

Weiter oben wurde trotzdem »putchar« mit Kenzahlen verwendet, um ein einfaches Beispiel für eine Verbundanweisung zu geben.

Übungsfragen zu Blöcken

? Geben Sie zu den folgenden Texten jeweils an, ob sie eine Verbundanweisung sind.

»{ ::std::putchar( 87 ); ::std::putchar( 87 ); }« Anton
»::std::putchar( 87 );« Berta
»{}« Cäsar
»{ ::std::putchar( 87 ) }« Dora
»{ {} }« Ida

/ Ausgabe

main.cpp

#include <cstdio> /* ::std::putchar */
int main()
{ ::std::putchar( 86 );
  ::std::putchar( 86 );
  ::std::putchar( 10 ); }

::std::cout

VV

Das obenstehende Programm gibt »VV« aus. Was gibt das folgende Programm aus?

main.cpp

#include <cstdio> /* ::std::putchar */
int main()
{ ::std::putchar( 86 ); /* Zeile 3 *
  ::std::putchar( 86 );  * Zeile 4 */
  ::std::putchar( 10 ); }

Die offizielle Bezeichnung nach der Sprachspezifikation *

C++ (2015-03-18): 6.3 Compound statement or block [stmt.block]; 1 So that several statements can be used where one is expected, the compound statement (also, and equivalently, called “block”) is provided.

Die Verbundanweisung in C++

»int main()« und die Verbundanweisung

Kennzahlen und Zeichen

Übungsfragen zu Blöcken

Die offizielle Bezeichnung nach der Sprachspezifikation *

»`int main()`« und die Verbundanweisung