Auswertungsanweisungen in C++

Wir lernen nun eine weitere Anweisung kennen, die Auswertungsanweisung. Diese kann verwendet werden, wenn die Ausgabe des Wertes, die beim Ausdruckrahmen erfolgt, nicht gewünscht ist. Die Wirkung der Ausführung des in sie eingesetzten Ausdrucks findet dann aber trotzdem statt. So wird es möglich, nur ein »G« auszugeben, falls dies gewünscht ist, also die Wirkung ohne den Wert zu erhalten.

Die Auswertungsanweisung besteht aus einem Ausdruck und einem Semikolon »;«.

Ein Ausdruck

::std::putchar( 86 )

Eine Auswertungsanweisung

::std::putchar( 86 );

Die Auswertungsanweisung kann überall dort in ein Programm hineingeschrieben werden, wo auch eine Ausgabeanweisung stehen darf.

main.cpp

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

::std::cout

Wir können nun frei zwischen den möglichen Kombinationen wählen:

1.) »V« und »86« ausgeben:

main.cpp

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

::std::cout

V86

Hier wird »::std::putchar( 86 )« ausgewertet und der Wert wird ausgegeben.

2.) Nur »V« ausgeben:

main.cpp

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

::std::cout

Hier wird »::std::putchar( 86 )« nur ausgewertet, ohne daß der Wert ausgegeben wird.

3.) Nur »86« ausgeben:

main.cpp

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

::std::cout

Das folgende Beispiel zeigt, wie man eine Wertfunktion ohne Wirkung normalerweise nicht aufrufen würde, weil der ermittelte Wert dabei verloren gehen würde.

main.cpp

#include <cstdlib>  /* ::std::rand */
int main()
{ ::std::rand(); }

::std::cout

(keine Ausgabe)

Die Aufrufanweisung verlangt lediglich die Auswertung ihres Aufrufausdrucks. Das Ergebnis dieser Auswertung wird bei der Aufrufanweisung aber nicht verwendet oder sichtbar, es geht verloren.

main.cpp

#include <cstdio>   // ::std::getchar
int main()
{ ::std::getchar(); }

::std::cout

(Warten auf Eingabe einer Zeile)

Die Funktion »::std::getchar« ist allerdings nicht gut geeignet, um auf die Eingabe einer Taste zu warten, weil sie das Programm unter bestimmten Bedingungen (wenn vorher schon Zeichen eingegeben wurden) nicht anhält. Allerdings kann dieses Verhalten auch verändert werden, aber bisher wurde noch nicht gezeigt, wie dies möglich ist.

Auswertungsanweisungen in C++

(Dieser Abschnitt diese Lektion entstand zunächst unabhängig und wiederholt daher teilweise einiges schon zuvor Gesagtes.)

Der Programmteil in den geschweiften Klammern der folgenden Beispielprogramme ist eine sogenannte Auswertungsanweisung.

Die Auswertungsanweisung besteht aus einem Ausdruck und einem Semikolon. Das Semikolon am Ende dieser Anweisung ist eine lexikalische Einheit.

Da sie – abgesehen von dem Semikolon am Ende - nur aus einem Ausdruck besteht, wird sie auch Ausdrucksanweisung oder Ausdruckanweisung genannt.

Eine Auswertungsanweisung, deren Ausdruck ein Aufruf ist, kann auch Aufrufanweisung genannt werden.

Weitere mögliche Bezeichnungen sind:

Aufrufanweisung (wenn der Ausdruck ein Aufruf ist),

Werteverwurf (weil der Wert des Ausdrucks nicht verwendet wird) oder

Wirkanweisung (weil der Sinn im Hervorrufen der Wirkung der Auswertung besteht).

Auswertungsanweisung (Beispiel)

::std::putchar( 86 );

Zerlegung einer Auswertungsanweisung

::std::putchar( 86 ) ;

'-----------------------------------' '-----------'
Ausdruck Semikolon

| |
'--------------------------------------------------------'
Auswertungsanweisung

Auswertungsanweisung (Syntaxdiagramm)

     .----------.      .-.
---->| Ausdruck |---->( ; )---->
     '----------'      '-'

Ein Ausdruck alleine – ohne folgendes Semikolon – ist keine Anweisung.

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

main.cpp

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

::std::cout

Die Auswertungsanweisung steht innerhalb der geschweiften Klammern.

Ein weiteres Beispiel:

main.cpp

int main(){ 4; }

::std::cout

Die Auswertung eines Literals hat keine Wirkung.

Bei der Ausführung der Auswertungsweisung wird die im Aufrufausdruck vor dem Semikolon »;« angegebene Anweisung ausgewertet, im Falle eines Funktionsaufrufs bedeutet dies die Ausführung des Aufrufs. Die Ausführung der Auswertungsanweisung führt also in solchen Fällen zu einem Aufrufvorgang. Die Wirkung der Anweisung »::std::putchar( 67 );« ist die Ausgabe des Zeichens C.

Ein Ausdruck bildet mit einem direkt folgenden Semikolon zusammen eine Auswertungsanweisung.

Die Wirkung der Ausführung einer Auswertungsanweisung ist die Auswertung ihres Ausdrucks.

Während die Auswertung eines Ausdrucks eine Wirkung haben und einen Wert ergeben kann, kann die Ausführung einer Anweisung immer nur einen Wirkung haben, aber nie einen Wert ergeben. (Kurz: Anweisungen haben keinen Wert.)

In die geschweiften Klammern kann allgemein eine Folge von Anweisungen geschrieben werden, und jede Anweisung kann dabei eine Ausgabeanweisung oder eine Auswertungsanweisung sein.

Folgen von Anweisungen

An Stelle einer Anweisung kann auch eine Folge von Anweisungen geschrieben werden, deren jede eine Auswertungsanweisung oder eine Ausgabeanweisung sein kann.

main.cpp

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

::std::cout

main.cpp

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

Protokoll

Vabc

Wdef

Übungen

/ Auswertungsanweisung: Welcher der folgenden Texte (ohne die umschließenden Anführungszeichen) ist nach dem oben Gesagten sicher eine Auswertungsanweisung?; o »::std::getchar()«
o »::std::getchar();«
o »::std::getchar«
o keiner der obigen Antwortvorschläge trifft zu
/ Lexikalische Einheiten zählen ⃗: Wie viele lexikalische Einheiten enthält die Auswertungsanweisung »::std::getchar();«?

? Die Semantik der Auswertungsanweisung

Ergänzen Sie den folgenden Satz durch das Einsetzen einer Form eines Verbes.

Satz: Bei der Ausführung der Auswertungsanweisung wird ihr Ausdruck __________.

? Anweisungen

Welche der beiden folgenden Anweisungen sind sinnvoll (d.h.: Welche der beiden folgenden Anweisungen haben eine Wirkung)?

Anweisungen: o »::std::cos( 0 );«
o »::std::cout << ::std::cos( 0 )<< "\n"s;«

? Anweisungen (1)

Welche der beiden folgenden Anweisungen sind sinnvoll (d.h.: Welche der beiden folgenden Anweisungen haben eine Wirkung)?

Anweisungen: o »::std::putchar( 86 );«
o »::std::cout << ::std::putchar( 86 )<< "\n"s;«

? Ausgaben

Welche Ausgabe erzeugt das folgende Programm? (Codierung: 86: »V«, 87: »W«)

main.cpp

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

Welche Ausgabe erzeugt das folgende Programm? (Codierung: 86: »V«, 87: »W«)

main.cpp

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

Welche Ausgabe erzeugt das folgende Programm? (Codierung: 86: »V«, 87: »W«)

main.cpp

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

Welche Ausgabe erzeugt das folgende Programm? (Codierung: 86: »V«, 87: »W«)

main.cpp

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

Zitate *

C++14 clause 5 paragraph 11: In some contexts, an expression only appears for its side effects. Such an expression is called a discarded-value expression. The expression is evaluated and its value is discarded.