Parameter in C++

Motivation Erst, wenn man auch die Parameterbeschreibungen in der Dokumentation von Funktionen richtig lesen kann, kann man nützliche Funktionen richtig aufrufen.

Argumenterwartungen

Einige Aufrufe, wie »::std::floor( 5.1 )«, werden mit einem Argumentausdruck geschrieben. Andere Aufrufe, wie »::std::rand()«, werden ohne Argumentausdruck geschrieben.

Tatsächlich muß »::std::floor« mit einem Argument aufgerufen werden. »::std::rand()« darf hingegen nicht mit einem Argument aufgerufen werden.

Die Information über die richtige Schreibweise des Aufrufs kann man der Dokumentation entnehmen. Funktionen, die ohne Argument aufgerufen werden sollen, haben in der Dokumentation leere Klammern (oder Klammern, die nur das Wort »void« enthalten).

Dokumentation von »::std::rand()« (gekürzt und überarbeitet)

#include <cstdlib>
int rand();

Ergibt eine Pseudo-Zufallszahl zwischen »0« (einschließlich) und »RAND_MAX« (einschließlich)

Bei Funktionen, die mit einem Argument aufgerufen werden müssen, findet sich in der Dokumentation in den runden Klammern eine Angabe über den Typ des erwarteten Arguments. Dies wird im folgenden weiter beschrieben werden.

Typerwartungen

Der Aufrufausdruck »::std::floor( 2.0 + 0.7 )« besteht aus einem Rahmen »::std::floor( … )« und einem an Stelle der Lücke »…« eingesetztem Argumentausdruck »2.0 + 0.7«.

Für diese Lücke »…« darf jedoch im allgemeinen nicht irgendein beliebiger Ausdruck (also ein Literal, Name, Operatorausdruck oder Aufrufausdruck) eingesetzt werden. Das folgende Programm zeigt, daß ein Zeichenfolgenliteral beispielsweise zu einer Fehlermeldung führt.

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( "alpha"s )<< "\n"s; }

Konsole (übersetzt, gekürzt und vereinfacht)

'floor' : akzeptiert kein Argument dieses Typs

Dokumentation von Typerwartungen

Die Lücken in den Argumentklammern werden auch Parameter genannt (männliches Substantiv mit Betonung auf der zweiten Silbe).

Um zu beschreiben, daß bestimmte Lücken in Rahmen nur Ausdrücke bestimmter Typen zulassen, ordnet man Parametern einen Typ zu, den man auch als Parametertyp bezeichnen kann. Zunächst akzeptiert ein Parameter dann Argumente des Parametertyps. Ein Parameter vom Typ »::std::string« akzeptiert also ein Argument vom Typ »::std::string«, nicht jedoch vom Typ »int« oder »double«. Umgekehrt akzeptiert ein Parameter vom Typ »int« oder »double« kein Argument vom Typ »::std::string«.

Damit man sich besser auf einen Parameter beziehen kann, hat ein Parameter auch einen Namen, den Parameternamen. Der Parametername ist eine abstrakte Bezeichnung für einen Wert (wie beispielsweise eine Zahl), welcher für einen Wert (wie beispielsweise eine Zahl) steht, welcher dann erst durch die Angabe eines Argumentausdrucks konkret bestimmt wird. Der Parametername einer Funktion hat jedoch für einen Aufruf dieser Funktion keine Bedeutung. Er erleichtert es nur, sich in der Dokumentation einer Funktion mit Hilfe des seines Namens auf den Parameter zu beziehen.

Dokumentation einer Funktion mit einem Parameter (übersetzt)

#include <cmath>
double floor( double x );

Die Funktion »floor« berechnet die größte ganze Zahl, welche nicht größer als »x« ist.

In der obenstehenden Dokumentation wird ein Parameter mit dem Typ »double« und dem Namen »x« dokumentiert. Die Funktion kann also mit einem Argument vom Typ »double« aufgerufen werden. In dem Text der Beschreibung der Funktion wird mit »x« auf den Argumentwert bezug genommen.

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

In der Dokumentation einer Funktion, die einen Parameter hat, findet man also eine Beschreibung (wie beispielsweise »double x«) dieses Parameters, die aus einem Typ und manchmal einem Namen besteht. Solche Parameterbeschreibungen und Argumentausdrücke werden manchmal miteinander verwechselt: Parameterbeschreibungen finden sich in der Dokumentation als Beschreibung einer Lücke, sie drücken das Fehlen eines bestimmten Wertes aus, die Erwartung eines Ausdrucks im Quelltextes beziehungsweise eines Wertes zur Laufzeit. Argumentausdrücke finden sich im Quelltext innerhalb mancher Ausdrücke und geben den zur Ermittlung des Parameterwerts zu nutzenden Ausdruck an, beispielsweise ein Numerale. Da Parameterbeschreibungen das Fehlen eines Wertes ausdrücken und Argumentausdrücken einen Wert, sind Argumentausdrücke gewissermaßen das Gegenstück von Parameterbeschreibungen.

Parametrisierung von Operationen

Die Operation »::std::floor( 2.7 )« ist die Abrundung des Werts 2,7. Sie ist ausführbar, weil sie vollständig bestimmt ist.

Das Ersetzen des konkreten Argumentausdrucks der Operation durch einen Parameter nennen wir Parametrisierung. Es handelt sich um einen Akt der Abstraktion, also der Entfernung eines Information.

Die Parametrisierung macht aus der speziellen Operation »::std::floor( 2.7 )« die allgemeine Funktion »::std::floor( double x )«.

Wenn es nur um die Berechnung von »::std::floor( 2.7 )« gehen würde, so könnte man auch eine spezielle parameterlose Funktion »::std::floor2o7()« bereitgestellt haben. Doch solch eine Funktion wäre nicht flexibel genug, da sie dann nicht zum Runden anderer Zahlenwerte verwendet werden könnte. Die Parametrisierung macht die Funktion flexibler, denn nun kann sie mit sehr vielen verschiedenen Argumentwerten kombiniert werden.

Daher sagen wir auch: Eine Funktion (mit einem Parameter) ist eine parametrisierte Operation, also eine Operation, der noch ein Wert fehlt, bevor sie auch wirklich ausgeführt werden kann.

Umgekehrt ist eine Operation eine Inkarnation (eine Anwendung, ein konkretes Exemplar) einer Funktion.

Das folgende Programmbeispiel zeigt eine Fehlermeldung beim Versuch eine parametrisierte Operation, ohne das notwendige Argument auszuführen.

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() << "\n"s; }

Konsole (gekürzt, übersetzt und vereinfacht)

'floor' : Funktion akzeptiert nicht 0 Argumente

Dies scheitert aus demselben Grund, aus dem es auch scheitern würde, einen Schallplattenspieler ohne Schallplatte zu starten.

Das Einsetzen eines Argumentausdrucks für einen Parameter nennen wir ja auch die Anwendung der Funktion auf den Argumentausdruck.

Der Argumentwert bestimmt den Wert des Parameters für eine bestimmte Auswertung, bei einer anderen Auswertung kann der Parameter wieder einen anderen Wert haben.

Bei der Anwendung einer Funktion mit einem Parameter auf ein Argument sagt man auch, daß der (abstrakte) Parameter mit dem (konkreten) Argumentwert besetzt werde. Man kann dann eine Operation also auch als eine besetzte Funktion ansehen, also eine Funktion, deren Parameter mit einem konkreten Wert besetzt wurde.

Aufrufwandlung und Untertypen

Das Literal »2« bezeichnet offensichtlich dieselbe Zahl wie das Literal »2.«, nämlich die Zahl Zwei. Der Datentyp von »2« ist aber »int«, während der Datentyp von »2.« »double« ist. Obwohl »2« und »2.« beide dieselbe Zahl Zwei bedeuten, sieht man in C++ in beiden zunächst zwei verschiedene Werte, denn sie unterscheiden sich im Datentyp. Man kann aber jedem int -Literal ein gleichwertiges double -Literal zuordnen, indem man an das int -Literal noch einen Punkt anfügt. Dementsprechend kann man jeden int -Wert einen gleichwertigen double -Wert zuordnen. Damit sind die int -Werte praktisch alle im Datentype »double« „enthalten“. Man kann »int« als Teil von »double« ansehen, als eine Art von „Untertyp“ von »double« (obwohl man in C++ in diesem Fall nicht von einem Untertyp spricht). Jedenfalls macht diese „Einbettung“ der int -Werte in den Datentyp »double« es verständlich, daß ein int -Argumentausdruck auch bei einem double -Parameter akzeptiert wird. Der int -Wert wird dabei im Zuge der Aufrufwandlung in den ihm gleichwertigen double -Wert umgewandelt.

Ein Parameter vom Typ »double« akzeptiert auch ein Argument vom Typ »int«.

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 )<< "\n"s; }

::std::cout

Umgekehrt ist es auch möglich, einen double -Argumentausdruck für einen int -Parameter anzugeben, obwohl es nicht sicher ist, ob dies immer sinnvoll ist.

Wenn für den Datentyp eines Parameters ein bestimmter Zahlentyp festgelegt wurde, dann ist es auch möglich, ein Argument eines anderen verträglichen Zahlentyps anzugeben, da der Wert des angegebenen Arguments dann implizit in den Parametertyp gewandelt wird.

main.cpp

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

::std::cout

Sind die Klammern hinter dem Funktionsnamen in der Dokumentation leer (oder enthalten sie nur das Wort »void«), so muß die dokumentierte Funktion ebenfalls mit leeren Klammern aufgerufen werden.

»::std::rand« [Dokumentation]

#include <cstdlib>
int rand();

Ergibt eine Pseudozufallszahl.

Übungsaufgaben

Beim Schreiben eines Programms mit Aufrufen von Funktionen

sollte nichts aus der Dokumentation in das Programm kopiert werden und
der vorgegebenen Ausdruckrahmen weiterhin nicht verändert werden.

/ Aufruf schreiben

Diese Übungsaufgabe soll das selbständige Schreiben von Aufrufen von Funktionen mit einem Parameter an Hand der Dokumentation üben.

Schreiben Sie ein Programm, welches das Ergebnis eines Aufrufs der folgenden Funktion ausgibt.

/ Dokumentation

#include <cmath>
double fabs( double x );

der Betrag von x

/ Aufruf schreiben (1) ʳ

Schreiben Sie ein Programm, welches das Ergebnis eines Aufrufs der folgenden Funktion ausgibt.

/ Dokumentation

#include <cmath>
double sqrt( double x );

die nichtnegative Wurzel von x

/ Aufruf schreiben (2) ʳ

Schreiben Sie ein Programm, welches das Ergebnis eines Aufrufs der folgenden Funktion ausgibt.

/ Dokumentation

#include <cmath>
double log( double x );

der natürliche Logarithmus von x

/ Mathematischen Aufruf schreiben

Die für diese Aufgabe benötigten Funktionen stehen nach »#include <cmath>« bereit.

Schreiben Sie möglichst kurze Ausdrücke, die der folgenden sprachlichen Bezeichnungen entsprechen, ohne dabei den Wert des Ausdrucks schon selber im Kopf auszurechnen! Der Wert des Ausdrucks sollte den mathematischen Werten der vorgegebenen Terme möglichst nahe kommen.

Der Kosinus von Null

/ Mathematische Aufrufe schreiben

Die für diese Aufgabe benötigten Funktionen stehen nach »#include <cmath>« bereit.

Die Wurzel aus 12 Prozent von 74

Sprachgebrauch *

Das, was in diesem Text hier als „Parameter“ bezeichnet wird, wird manchmal auch Formalparameter, formaler Parameter oder formales Argument (“formal argument ”) genannt. Das, was in diesem Text hier als „Argument“ (oder „Argumentausdruck“ oder „Argumentwert“) bezeichnet wird, wird manchmal auch Aktualparameter, aktueller Parameter oder aktuelles Argument genannt. Manche unterscheiden auch gar nicht zwischen „Parameter“ und „Argument“, sondern nennen beides „Parameter“ oder beides „Argument“.

Auch in n3290 werden die Bezeichnungen “parameter ” (8.2) für „Parameter“ beziehungsweise “argument ” (5.2.2) für „Argument“ verwendet.