C++ Sequenzpunkt C++ Sequenzpunkte C++ Komma C++ Kommaoperator C++ Operator C++ Seiteneffekt C++ Seiteneffekte C++

Auswertung mit unbestimmter Reihenfolge

In dieser Lektion wird darauf hingewiesen, daß die Reihenfolge der Auswertung von Teilausdrücken oft unbestimmt ist.

In der letzten C++ -Norm von 2017 wurden jedoch inzwischen für einige Operatoren zusätzliche Bestimmungen einer Reihenfolge vorgenommen. Viele Compiler berücksichtigen diese aber noch nicht. Auch dieser Kurs gibt teilweise noch einen Stand von vor C++17 wieder.

#include <iostream> /* ::std::cout  */
#include <ostream>  /* <<           */
#include <cmath>  /* ::std::pow  */
#include <cstdio>  /* ::std::putchar   */
int main()
{ ::std::cout << 
  ::std::putchar( 65 )+ ::std::putchar( 66 )<<
  "\n"; }

Zur ersten Interpretation äquivalentes Programm

#include <iostream> /* ::std::cout  */
#include <ostream>  /* <<           */
#include <cmath>  /* ::std::pow  */
#include <cstdio>  /* ::std::putchar   */
int main()
{ auto const a { ::std::putchar( 65 ) };
  auto const b { ::std::putchar( 66 ) };
  ::std::cout << 
   a + b <<
  "\n"; }

Zur zweiten Interpretation äquivalentes Programm

#include <iostream> /* ::std::cout  */
#include <ostream>  /* <<           */
#include <cmath>  /* ::std::pow  */
#include <cstdio>  /* ::std::putchar   */
int main()
{ auto const b { ::std::putchar( 66 ) };
  auto const a { ::std::putchar( 65 ) };
  ::std::cout << 
   a + b <<
  "\n"; }

Spionagefunktionen

Durch Ausgabeanweisungen in Funktionsdeklarationen kann die Auswertung von Ausdrücken verfolgt („ausspioniert“) werden.

main.cpp

#include <cstdlib>
#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int r( int const a )
{ ::std::cout << a << "\n"s; return rand(); }
int main()
{ 0 * r( 10 ) + 1 * r( 11 );
  1 * r( 20 ) + 0 * r( 21 ); }

Protokoll

Man erkennt, daß bei der verwendeten C++ -Implementation einmal der linke und einmal der rechte Summand zuerst ausgewertet wird.

Das folgenden Programm zeigt, daß bei der verwendeten Implementation, der weiter rechts stehende Operand »r( 20 )« vor dem weiter links stehenden Operand »l( 10 )« ausgewertet wird, obwohl sein Wert »20« hinter den Wert des weiter links stehenden Operanden geschrieben wird. (Die Reihenfolge der Auswertung von Operanden ist für den Operator »>>« nicht durch die Sprachnorm festgelegt, so daß jede Implementation die Freiheit hat, die Reihenfolge selber festlegen zu können.)

main.cpp

#include <cstdlib>
#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int r( int const a )
{ ::std::cout << "["s << a << "]\n"s; return a; }
int main()
{ ::std::cout << r( 10 )<< r( 20 )<< '\n'; }

Protokoll

[20]
[10]
1020

Sequenzierung

Lesehinweis: Falls die in diesem Abschnitt erklärte Unbestimmtheit der Reihenfolge beim ersten Lesen als unverständlich oder zu verwirrend erscheinen sollte, ist es am besten, sie vorläufig zu ignorieren, da der größte Teil des folgenden Kurses auch ohne sie gut verständlich ist. In diesem Fall sollte dieser Abschnitt später noch einmal gelesen werden.

In der Mathematik kann man Terme, die nicht voneinander abhängen, in beliebiger Reihenfolge hintereinander ausrechnen.

2×3 + 4×5
zuerst "2×3" | zuerst "4×5"
.----------------'----------------.
| |
6 + 4×5 2×3 + 20

6 + 20 6 + 20
26 26

Das Ergebnis ist unabhängig von der Reihenfolge der Berechnung.

Wenn zu einem bestimmten Zeitpunkt während der Ausführung eines Programms mehrere Operationen möglich sind, dann ist ihre Reihenfolge durch C++ nicht festgelegt!

So ist es durch C++ nicht festgelegt, in welcher Reihenfolge das folgende Programm die Zeichen »A« und »B« ausgibt.

main.cpp

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

::std::cout

BA6566

::std::cout

AB6566

::std::cout

A65B66

Was bei »<<« festgelegt ist, ist die Reihenfolge der Ausgabe: »65« steht immer vor »66«. Außerdem muß »A« immer vor »65« erscheinen und »B« immer vor »66«. Was nicht festgelegt ist, ist die Reihenfolge der Auswertung (und damit der Wirkung) der putchar-Ausdrücke.

Mögliche Ausführungen wie in:

main.cpp

#include <iostream> /* ::std::cout    */
#include <ostream>  /* <<             */
#include <cstdio>   /* ::std::putchar */
int main()
{ auto const a { ::std::putchar( 65 ) };
  auto const b { ::std::putchar( 66 ) };
  ::std::cout << a;
  ::std::cout << b;
  ::std::cout << "\n"; }

Protokoll

AB6566

main.cpp

#include <iostream> /* ::std::cout    */
#include <ostream>  /* <<             */
#include <cstdio>   /* ::std::putchar */
int main()
{ auto const b { ::std::putchar( 66 ) };
  auto const a { ::std::putchar( 65 ) };
  ::std::cout << a;
  ::std::cout << b;
  ::std::cout << "\n"; }

Protokoll

BA6566

main.cpp

#include <iostream> /* ::std::cout    */
#include <ostream>  /* <<             */
#include <cstdio>   /* ::std::putchar */
int main()
{ auto const a { ::std::putchar( 65 ) };
  ::std::cout << a;
  auto const b { ::std::putchar( 66 ) };
  ::std::cout << b;
  ::std::cout << "\n"; }

Protokoll

A65B66

Die ausgegebenen Zeichen selber und dann ihre Reihenfolge sind beide nicht durch die Programmiersprache C++, sondern die verwendete Implementation bestimmt!

Beispiel Reihenfolge von Operationen mit Konstanteninitialisierungen bestimmen

unbestimmte Reihenfolge der putchar-Operationen

{ ::std::cout << ::std::putchar( 65 )<< ::std::putchar( 66 )<< "\n"; }

bestimmte Reihenfolge der putchar-Operationen

{ auto const putchar_65 = ::std::putchar( 65 );
  auto const putchar_66 = ::std::putchar( 66 );
  ::std::cout << putchar_65 << putchar_66 << "\n"; }

In dem obigen Block kann nicht »constexpr« verwendet werden, weil die Werte von constexpr -Konstanten schon beim Übersetzen eines Programms feststehen müssen, während der Wert von ::std::putchar -Aufrufen aber erst zur Laufzeit festgelegt wird. Würde aber statt »::std::putchar« eine Funktion aufgerufen werden, deren Wert schon beim Übersetzen festgelegt wird, so könnte statt »auto const« auch »constexpr auto« verwendet werden.

Sequenzpunkte Unvollständige Angabe von Sequenzpunkten

Anders als die meisten Operatoren von C++ definiert der Operator "&&" einen Sequenzpunkt : Der linke Operand wird zuerst ausgewertet.

Ein bedingter Ausdruck definiert auch einen Sequenzpunkt : Alle Wirkungen des ersten Ausdrucks vor dem Fragezeichen "?" sind eingetreten, bevor die Auswertung eines der folgenden Operanden beginnt.

C++14 clause 1 section 9 paragraphs 13 – 15 (gekürzt und leicht überarbeitet): Given any two evaluations A and B, if A is sequenced before B, then the execution of A shall precede the execution of B.; If A is not sequenced before B and B is not sequenced before A, then A and B are unsequenced.; [Note: The execution of unsequenced evaluations can overlap. – end note]; Evaluations A and B are indeterminately sequenced when either A is sequenced before B or B is sequenced before A, but it is unspecified which.; [Note: Indeterminately sequenced evaluations cannot overlap, but either could be executed first. – end note]; Except where noted, evaluations of operands of individual operators and of subexpressions of individual expressions are unsequenced.; [Note: In an expression that is evaluated more than once during the execution of a program, unsequenced and indeterminately sequenced evaluations of its subexpressions need not be performed consistently in different evaluations. – end note]; The value computations of the operands of an operator are sequenced before the value computation of the result of the operator.