Trägheit von Operandenstellen in C++

Strikte Stellen

Beide Stellen des Additionsoperators "+" sind strikt, da die zugehörigen Operanden immer ausgewertet werden. In dem Programmbeispiel "strict.cpp" werden beispielsweise beide Operanden des Additionsoperators ausgewertet. Dies kann man auch an der Wirkung der Aufrufe der Wertwirkfunktionen sehen. Der Grund für die Striktheit des Additionsoperators ist es natürlich, daß zur Addition in jedem Fall auch die Werte der beiden Summanden benötigt werden.

strict.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>

using namespace ::std::literals;

namespace
{ int u() { ::std::cout << "u"s; return 1; }
  int v() { ::std::cout << "v"s; return 1; }}

int main(){ u() + v(); ::std::cout << "\n"s; }

System.out

uv

Übungsfrage Welchen Wert hat der Ausdruck "u() + v()" in dem Programm "strict.cpp"?

Übungsfrage Ist die Ausgabe des Programms "strict.cpp" durch die Programmiersprache C++ eindeutig bestimmt?

Träge Stellen

Der Operator "&&" ist ein linksassoziativer zwischengestellter binärer Operator.

〈logical-and-expression 〉 ::=: 〈inclusive-or-expression 〉 |; 〈logical-and-expression 〉 "&&" 〈inclusive-or-expression 〉.

Die Priorität dieses Operators ist niedriger als die der meisten anderen Operatoren, aber höher als die des Zuweisungsoperators.

Die Werte der Operanden dieses Operators werden zunächst implizit in den Datentyp "bool" gewandelt.

Die rechte Stelle des Operators "&&" ist träge, denn ihr Operand wird nur dann ausgewertet, wenn der gewandelte Wert des linken Operanden der Wert "true" ist.

In dem Programm "lazy.cpp" wird zuerst der Ausdruck "t() && f()" ausgewertet. Da hier der linke Operand den Wert "true" hat, wird auch der rechte Operand ausgewertet. So entsteht die Ausgabe "T F " der ersten Ausgabezeile. Später wird der Ausdruck "f() && t()" ausgewertet: In diesem Fall hat der linke Operand den Wert "false", so daß der zweite Operand nicht mehr ausgewertet wird und die zweite Ausgabezeile dementsprechend nur den Text "F " enthält.

Der Wert des Ausdrucks "t() && f()" und des Ausdrucks "f() && t()" ist jeweils der Wert "false". Dieser Wert wird aber in dem Programm "lazy.cpp" nicht verwendet. Der Wert der Operation "&&" ist nur dann "true", wenn die Werte beider Operanden gleich dem Wert "true" sind—sonst ist er immer der Wert "false". Da in dem Beispielprogramm nie beide Operanden den Wert "true" haben, ergibt sich dort stets der Wert "false" als Ergebnis der Operation.

lazy.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>

using namespace ::std::literals;

namespace
{ int t() { ::std::cout << "T "s; return true;  }
  int f() { ::std::cout << "F "s; return false; }}

int main()
{ t() && f(); ::std::cout << "\n"s; 
  f() && t(); ::std::cout << "\n"s; }

System.out

T F 
F

Aufrufsteuerung

Wenn der Operand einer trägen Stelle ein Funktionsaufruf ist, dann erfolgt dieser auch nur dann, wenn der Operand überhaupt ausgewertet wird. Ein Aufruf als Operand einer trägen Stelle wird also nicht immer ausgeführt, sondern nur unter bestimmten Umständen. Wenn die Auswertung einer trägen Stelle beispielsweise in Abhängigkeit von den Werten bestimmter Operanden erfolgt, dann können diese Operandenwerte sozusagen steuern, ob die Auswertung einer Stelle erfolgt, also beispielsweise auch, ob eine bestimmte Funktion aktiviert wird.

Das folgende Programmbeispiel zeigt Funktionsaufrufe, die genau dann ein Sternchen ausgeben, falls ihr Argumentwert "true" ist.

sternchen.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>

using namespace ::std::literals;



namespace
{ bool sternchen() { ::std::cout << "* "s; return true;  }
  bool sternchen( bool const i ) { return i && sternchen(); }}

int main()
{ ::std::cout << "true : "s; sternchen( true );  ::std::cout << "\n"s; 
  ::std::cout << "false: "s; sternchen( false ); ::std::cout << "\n"s; }

System.out

true : * 
false:

Das Programmbeispiel "sternchen1.cpp" zeigt, wie die Funktion "sternchen" für Argumentwerte zwischen 1 und 3 die durch den Argumentwert angegebene Zahl von Sternchen ausgibt.

Sternchen1.java

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>

using namespace ::std::literals;

namespace
{ bool sternchen_b( int const i ) 
  { ::std::cout << "*"s; return i > 1;  }
  bool sternchen_a( int const i ) 
  { ::std::cout << "*"s; return i > 1 && sternchen_b( i - 1 );  }
  bool sternchen( int const i )  
  { ::std::cout << "*"s; return i > 1 && sternchen_a( i - 1 );  }}

int main()
{ sternchen( 1 ); ::std::cout << "\n"s; 
  sternchen( 2 ); ::std::cout << "\n"s; 
  sternchen( 3 ); ::std::cout << "\n"s; }

System.out

* 
** 
***

Übungsfrage Erklären Sie genau, wie die Ausgabe des Programms "sternchen.cpp" zustande kommt.

Übungsfrage Welche Unterschiede gibt es zwischen der Funktion "sternchen" und "sternchen_a"?

In dem Programm "sternchen.cpp" rief die Funktion "sternchen" unter Umständen die ihr fast gleiche Funktion "sternchen_a" auf. Tatsächlich kann die Funktion "sternchen" anstelle der anderen Funktion "sternchen_a" genauso gut sich selbst wieder aufrufen, wie in dem Programm "sternchen2.cpp".

sternchen2.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>

using namespace ::std::literals;

namespace
{ bool sternchen( int const i )  
  { ::std::cout << "*"s; return i > 1 && sternchen( i - 1 );  }}

int main()
{ sternchen( 1 ); ::std::cout << "\n"s; 
  sternchen( 2 ); ::std::cout << "\n"s; 
  sternchen( 3 ); ::std::cout << "\n"s; }

System.out

* 
** 
***

Übungsfrage Erklären Sie genau, wie die Ausgabe des Programms "sternchen2.cpp" zustande kommt.

Übungsfrage Der Parameter "i" steht für einen konstanten Wert. Steht dies nicht im Widerspruch dazu, daß der Wert des Parameters "i" sich im Laufe des Aufrufs "sternchen( 2 )" scheinbar verändert?

Übungsaufgabe Verfolgen Sie den Ablauf des Aufrufs "sternchen( 3 )" mit einem Debugger.

Wenn eine Funktion aufgrund eines Aufrufs der Funktion aktiviert wird, dann wird ein neues Exemplar der Funktion erzeugt. Ein Exemplar einer Funktion wird manchmal auch als eine Instanz oder als eine Inkarnation der Funktion bezeichnet.

Ein Exemplar einer Funktion kann man sich als eine Verwirklichung oder eine Kopie der Funktion für einen bestimmten Aufruf vorstellen. Entscheidend für das Verständnis ist es, daß dabei auch neue Exemplare aller Parameter erzeugt werden, die hier auch als Parameterexemplare bezeichnet werden. Endet die Aktivität eines Funktionsexemplars, so wird das Funktionsexemplar mit allen seinen Parameterexemplaren wieder aufgelöst (vernichtet).

Die Auswertung des Ausdrucks "sternchen( 3 )" erzeugt ein Exemplar der Funktion "sternchen" mit einem Exemplar des Parameters "i". In der folgenden Ablaufdarstellung wird dieses erzeugte Exemplar der Funktion "sternchen0" mit dem Namen "sternchen0" bezeichnet und das Exemplar des Parameters "i" wird mit dem Namen "i0" bezeichnet.

Ablaufdarstellung [Pseudo-Code]

sternchen( 3 );

bool sternchen( int const i0 ) // i0 = 3 
{ ::std::cout << "*"s; return i0 > 1 && sternchen( i0 - 1 );   
  bool sternchen( int const i1 ) // i1 = 2 
  { ::std::cout << "*"s; return i1 > 1 && sternchen( i1 - 1 );   
    bool sternchen( int const i2 ) // i2 = 1 
    { ::std::cout << "*"s; return i2 > 1 && sternchen( i2 - 1 ); }}}

Im Rumpf des Funktionsexemplars "sternchen0" erfolgt dann der Aufruf "sternchen( i0 - 1 )". Dadurch wird ein weiteres Exemplar der Funktion "sternchen" erzeugt und das Parameterexemplar "i1" des neuen Exemplars erhält den Wert 2. Jedes der beiden bisher genannten Exemplare des Parameters "i" ist konstant, es handelt sich aber um zwei unterschiedliche Parameterexemplare zweier unterschiedlicher Exemplare der Funktion "sternchen", daher liegt hier kein Widerspruch dazu vor, daß der Parameter "i" konstant ist. Wenn man sagt, der Parameter "i" sei konstant, dann meint man damit nämlich, daß jedes einzelne Parameterexemplar konstant ist. Anschließend wird die Funktion "sternchen" noch einmal aktiviert, aber da dann das Parameterexemplar "i2" nicht mehr größer als 1 ist, wird sie danach nicht noch ein weiteres Mal aktiviert.

Allgemein gilt: Parameterexemplare werden bei Aktivierung einer Funktion neu erzeugt. Wird eine Funktion erneut aktiviert, wird auch jedes Parameterexemplar erneut erzeugt—auch dann, wenn andere Exemplare derselben Funktion noch aktiv sind, weil die Funktion sich (direkt oder indirekt) selbst aufruft. Jedes Parameterexemplar einer Funktion kann einen eigenen Wert haben.

Ein einziger Parametername, wie der Bezeichner "i", kann also für mehrere Parameterexemplare stehen, falls die Funktion des Parameters mehrfach aufgerufen wird.

Und-Verknüpfung

Die Operation "&&" kann auch als eine Und-Verknüpfung ihrer Operandenwert angesehen werden. Das Ergebnis einer Und-Verknüpfung ist nur dann der Wert "true", wenn beide Operanden den Wert "true" haben. Falls der erste Operandenwert bereits den Wert "false" hat, dann braucht der zweite Operand gar nicht erst ausgewertet zu werden, weil dann bereits klar ist, daß der Und-Ausdruck den Wert "false" hat.

Das folgende Programm verwendet den Operator "&&" um zu erreichen, daß ein Sternchen nur dann ausgegeben wird, wenn der Wert einer Zahl zwischen 1 und 6 ist.

Sternchen3.java

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>

using namespace ::std::literals;



namespace
{ bool sternchen() { ::std::cout << "*"s; return true;  }
  bool sternchen( int const i ){ return i >= 1 && i < 7 && sternchen();  }}

int main()
{ ::std::cout << "0: "; sternchen( 0 ); ::std::cout << "\n"s; 
  ::std::cout << "3: "; sternchen( 3 ); ::std::cout << "\n"s; 
  ::std::cout << "9: "; sternchen( 9 ); ::std::cout << "\n"s; }

System.out

0:  
3: * 
9: