Argumente in C++

main.cpp

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

::std::cout

Wir sehen in dem obigen Programm eine neue Möglichkeit zum Schreiben eines Aufrufausdrucks : Die runden Aufrufklammern müssen nicht immer leer sein, sie können auch einen Ausdruck (also ein Literal, Namen, Operatorausdruck oder weiteren Aufrufausdruck) enthalten!

Aufrufausdruck (Syntaxdiagramm)

Aufrufausdruck
        .----------.     .----.         .------.     .---.         .--------.         .---.
---.--->|Namensraum|--->(  ::  )---.--->| Name |--->(  (  )---.--->|Ausdruck|---.--->(  )  )--->
   |    '----------'     '----'    ^    '------'     '---'     \   '--------'  /      '---'
   '-------------------------------'                            '----------->-'

Dies sieht man am Aufrufausdruck »::std::floor( 2.7 )« (d.h., die größte ganze Zahl vom Typ »double«, welche nicht größer als »2.7« ist): Hier ist »::std« der Namensraum, »floor« der Name und »2.7« der Ausdruck des Aufrufausdrucks.

Eine in die Aufrufklammern geschriebener Ausdruck wird auch Argumentausdruck des Aufrufs oder kurz Argumentausdruck genannt. Die Aufrufklammern, welche das Argument enthalten, werden entsprechend hier auch manchmal als Argumentklammern bezeichnet. Der Wert des Argumentausdruck ist der Argumentwert. Wenn es nicht wichtig ist zwischen dem Argumentausdruck und Argumentwert zu unterscheiden, so spricht am auch einfach nur von eine Argument. Dann muß dem Zusammenhang entnommen werden, ob damit der Argumentausdruck oder der Argumentwert gemeint ist – manchmal sind auch beide Interpretationen gleichzeitig möglich.

Das Wort „Argument“ stammt vom lateinischen Substantiv "argumentum", was soviel bedeutet wie „etwas, was der Erhellung und Veranschaulichung dient“, nach dem lateinischen Verb "arguere" (erhellen/beweisen).

Der Argumentausdruck in einem Aufrufausdruck entspricht dem Operandenausdruck eines Operatorausdrucks. Der Sinn ist derselbe, nur spricht man bei einem Aufrufausdruck eben von einem Argumentausdruck und nicht von einem Operandenausdruck. Beispielsweise entspräche dem Operatorausdruck »-2« der Aufrufausdruck »minus( 2 )«.

Die runde Klammer auf »(« wird im Deutschen meist als „von“ gesprochen. So ist »::std::floor( 2.7 )« „»::std::floor« von Zwei Komma Sieben“. In manchen Fällen kann man »cos( 0 )« auch einfach „Kosinus Null“ sprechen, etwa wenn der Ausdruck als untergeordnet markiert werden soll: »log( cos( 0 )+ sin( 0 ))« „Logarithmus von Kosinus Null plus Sinus Null“.

Ein Aufrufausdruck

::std::floor( 2.7 )

auf deutsch:

Aufruf von floor mit dem Argumentwert 2,7

Wert von floor für den Argumentwert 2,7

floor von 2,7

Semantik

Bei der Auswertung eines Aufrufs mit einem Argument wird zuerst der Argumentwert ermittelt. Dann wird die aufgerufene Funktion mit dem Argumentwert inkarniert (also verbunden) und schließlich wird die Inkarnation (das Ergebnis der Verbindung) ausgeführt. Die ausgeführte Inkarnation kann dann den Wert des Aufrufausdrucks festlegen.

Übergabe des Argumentwerts

Da beim Aufruf einer Funktion der Wert des Argumentausdrucks zur Laufzeit zusammen mit der Kontrolle an die aufgerufene Funktion übergeben wird, spricht man auch von der Übergabe des Argumentwertes oder sagt, der Argumentwert werde an die aufgerufene Funktion übergeben.

Übergabe und Rückgabe der Kontrolle zur Laufzeit

.--------------------------------------------.
| Hauptprogramm----.                         |
|                  | Übergabe der Kontrolle  |
|                  V und des Argumentwertes  |
|          .---------------.                 |
|          | Unterprogramm |                 |
|          '---------------'                 |
|                  |                         |
|                  |                         |
|<-----------------'                         |
| Rueckgabe der Kontrolle                    |
| und des Ergebniswertes                     |
'--------------------------------------------'

»main« und »floor« bei der oben gezeigten Ausführung

.--------------------------------------------.
| main ------------.                         |
|                  | Übergabe der Kontrolle  |
|                  V und des Wertes 2,7      |
|          .---------------.                 |
|          | floor         |                 |
|          '---------------'                 |
|                  |                         |
|                  |                         |
|<-----------------'                         |
| Rueckgabe der Kontrolle                    |
| und des Wertes 2,0                         |
|                                            |
'--------------------------------------------'

Das folgende Programmbeispiel verdeutlicht, daß im Quelltext nur die Argumentausdrücke nicht aber die Argumentwerte stehen, denn letztere werden erst zur Laufzeit ermittelt, daher können sich dann Ausgaben ergeben, welche durch Lesen des Quelltextes nicht vorhersagbar sind.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <cmath>    // ::std::floor
#include <cstdlib>  // ::std::rand
#include <string>   // ""s
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::floor( ::std::rand()/10. )<< "\n"s; }

::std::cout

Beispiele

Beispiel

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <cmath>    // ::std::floor
#include <string>   // ""s
using namespace ::std::literals;
int main() { ::std::cout << ::std::floor( 2.0 + 0.7 )- 1.7 << "\n"s; }

::std::cout

0.3

An diesem Beispiel kann man auch den Unterschied zwischen dem Argumentausdruck und den Argumentwert gut erkennen: »2.0 + 0.7« ist der Argumentausdruck, »2.7« ist der Argumentwert.

Operationssequenz

::std::floor( 2.0 + 0.7 )- 1.7: 2.0 + 0.7 → 2.7; ::std::floor( 2.7 ) → 2; 2 - 1.7 → 0.3; ☐

Übungsfragen

? Übungsfrage

Was ist der Argumentausdruck in »::std::floor( 2.0 + 0.7 )«?

Was ist der Argumentwert in »::std::floor( 2.0 + 0.7 )«?

? Ermittlung von Operanden ⃗

Kann es eine Funktion »f« geben, die wie in den folgenden Beispielen gezeigt, den linken Operanden ihres Argumentausdrucks ergibt?

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
#include ...        // f // hypothetische Funktion
using namespace ::std::literals;
int main()
{ ::std::cout << f( 1 + 3 )<< "\n"s; }

::std::cout

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
#include ...        // f // hypothetische Funktion
using namespace ::std::literals;
int main()
{ ::std::cout << f( 2 + 2 )<< "\n"s; }

::std::cout

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
#include ...        // f // hypothetische Funktion
using namespace ::std::literals;
int main()
{ ::std::cout << f( 3 + 1 )<< "\n"s; }

::std::cout