Mehrere Parameter in C

Einleitendes Beispiel

Das folgende Beispiel zeigt »pow( 10.0, 2.0 )« (/paʊ/), die C -Schreibweise für die Potenz ‹ 10² › (‹ 10² › bezeichnet den Wert, den man erhält, wenn man die Zahl Eins 2 -mal mit 10 multipliziert.).

main.c

#include <stdio.h>
#include <math.h>
int main( void )
{ printf
  ( "%g\n", pow( 10.0, 2.0 )); }

stdout

Das nächste Programm zeigt die Berechnung der Potenz ‹ 2¹º ›. Hierzu wurde die Reihenfolge der Argumente vertauscht.

main.c

#include <stdio.h>
#include <math.h>
int main( void )
{ printf
  ( "%g\n", pow( 2.0, 10.0 )); }

stdout

1024.0

Die Reihenfolge, in der die Argumente geschrieben werden, bestimmen also im allgemeinen den Wert des Funktionsaufrufs mit.

Dokumentation

Dieser Abschnitt stellt die Dokumentation der Funktion »pow« als Beispiel der Dokumentation einer Funktion mit mehreren Parametern vor. Mehrere Parameterbeschreibungen werden in der Dokumentation in den runden Klammern jeweils durch ein Komma getrennt.

Dokumentation einer Funktion mit zwei Parametern (nach N1570, überarbeitet und übersetzt)

7.12.7.4 Die Funktion »pow«

Synopse

#include <math.h>
double pow( double x, double y );

Beschreibung

Die Funktion pow berechnet x hoch y.

Ergebnis

Die Funktion pow ergibt x ʸ.

Die Funktion »pow« ergibt das Ergebnis der Potenzierung des ersten Argumentes mit dem zweiten Argument (also das erste Argument „hoch“ das zweite Argument). Die voranstehende Dokumentation stellt klar, daß zwei Argumente erwartet werden und daß ein Ergebnis geliefert wird.

Syntax

Das folgende Syntaxdiagramm für Aufrufausdrücke ist nun gegenüber einer frühere Version erweitert, um die Möglichkeit mehrerer durch ein Komma getrennter Argumente darzustellen. Es sind auch mehr als die in den Beispielen dieser Lektion gezeigten zwei Argumente möglich, beispielsweise drei Argumente.

Mehrere Argumente werden als Ausdruckliste in die runden Aufrufklammern geschrieben und durch ein Komma getrennt. Dieses Komma stellt eine lexikalische Einheit dar, wie man auch dem folgenden Syntaxdiagramm entnehmen kann.

Aufrufausdruck (Syntaxdiagramm)

Ausdruckliste
   .---------------------------.            
   |        .----------.       v
---'---.--->| Ausdruck |---.---'--->
       ^    '----------'   |
       |        .-.        |
       '-------( , )<------'
                '-'
Ausdruck
    .----------------.     .-.     .---------------.     .-.    
--->| Funktionsname  |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '----------------'     '-'     '---------------'     '-'

Ausdruckliste (Beispiel)

10, 2

Aufrufausdruck (Beispiel)

pow( 10, 2 )

Eine in den Argumentklammern eines Funktionsaufrufs verwendete Ausdruckliste wird auch Argumentliste genannt.

In der Dokumentation finden sich die Parameter in den runden Klammern hinter dem Funktionsnamen aufgelistet, diese Liste der Parameter wird auch Parameterliste genannt.

Beim Schreiben des Aufrufs der Funktion müssen genau so viele Argumente angegeben werden wie Parameter in der Dokumentation stehen.

Die Zuordnung der Argumentwerte zu den Parametern erfolgt über deren gemeinsame Reihenfolge: Das erste Argument wird dem ersten Parameter zugeordnet, das zweite dem zweiten Parameter und so weiter. Bei der Inkarnation der Funktion wird dann der Wert jedes Parameters durch den Wert des entsprechenden Argumentausdrucks festgelegt. Der Aufruf »pow( 2, 3 )« legt beispielsweise den Wert »2.0« für den Parameter »x« und den Wert »3.0« für den Parameter »y« fest. Dementsprechend bedeutete dieser Aufruf dann 2³ und nicht 3².

Typregeln

Der Typ des Aufrufs einer Funktion steht – wie schon früher behandelt – in der Dokumentation vor dem Namen der Funktion.

Damit eine Argumentliste mit einer Parameterliste verträglich ist, müssen die beisen Listen gleich viele Einträge haben und die Typen der Argumente müssen mit den Typen der jeweiligen Parameter verträglich sein (so wie dies bei einem Aufruf mit einem Argument schon behandelt wurde).

Eine Funktion muß mit so vielen Argumenten aufgerufen werden, wie sie Parameter hat.

Der Typ jedes Arguments muß so mit dem Typ des Parameters an derselben Position verträglich sein wie bei einer Funktion mit einem Parameter.

Im Aufruf »pow( 4, 3 )« wird beispielsweise das Argument »4« zur Festlegung des Wertes des Parameters »x« verwendet. Der Parameter »x« hat den Typ »double«. Daher muß der Argumenttyp nun so mit dem Parametertyp verträglich sein, wie dies zuvor schon bei der Behandlung von Funktionen mit einem Parameter erklärt wurde. Der Datentyp des Arguments »4« ist »int«, der Datentyp des Paramters »a« ist »double«. Wie schon vorher bei der Behandlung von Funktionen mit einem Parameter erklärt wurde, kann man für einen double-Parameter auch einen int-Ausdruck als Argument angeben. Für das zweite Argument »3« und den zweiten Parameter »y« gilt das Gesagte entsprechen. Daher erfüllt der Aufrufausdruck »pow( 4, 3 )« die dokumentierten Typanforderungen der Funktion.

Semantik

Bei der Auswertung eines Aufrufausdrucks werden zuerst alle Argumentausdrücke ausgewertet. Anschließend wird die durch den Funktionsnamen angegebenen Funktion mit den im vorigen Schritt ermittelten Werten der Argumente verbunden. Solch eine Verbindung einer Funktion mit konkreten Argumentwerten wird auch eine Inkarnation (der Funktion) genannt, genauso wird auch die Herstellung dieser Verbindung genannt. Die Inkarnation wird dann ausgeführt (also als Programm gestartet), diese Ausführung der Inkarnation wird hier auch Funktionsoperation genannt.

Eine Funktionsoperation ist also der letzte Schritt bei der Auswertung eines Funktionsaufrufs, der beginnt nachdem die Werte aller Argumente schon ermittelt wurden.

Entsprechend ist eine Operatoroperation der letzte Schritt bei der Auswertung eines Operatorausdrucks, der beginnt nachdem die Werte aller Operanden ermittelt wurden.

Funktionsoperationen und Operatoroperationen bezeichnen wir zusammenfassend auch als Operationen.

Bei mehreren Argumenten einer Funktion ist die Reihenfolge ihrer Auswertung in Fällen wie in dem obigen Beispiel eigentlich egal. In C ist hierfür auch keine bestimmte Reihenfolge der Auswertung der Argumente festgelegt. Es ist also der Implementation überlassen, ob das erste Argument oder das zweite Argument zuerst ausgewertet wird.

Dokumentation der Semantik

Die Dokumentation einer Funktion beschreibt auch, wie der Wert des Aufrufs einer festgelegt wird. Sie gibt also die Semantik eines Aufrufs dieser Funktion an. Der Wert des Aufrufs einer Funktion hängt oft von den Werten der Argumente ab und manchmal auch von anderen Umständen. Die Dokumentation beschreibt, wie der Wert des Aufrufs der Funktion von den Werten der Argumente und von anderen Umständen abhängt.

Im Falle der Funktion »pow« wird die Semantik beispielsweise durch den Text „Die Funktion pow ergibt x ʸ.“ aus ihrer Dokumentation bekannt gemacht.

Aussprache

Im allgemeinen spricht man »f(x,y)« als „f von x und y“, bei speziellen Funktionen werden jedoch auch spezielle Aussprachen verwendet, so ist »pow(x,y)« „x hoch y“.

Anmerkung zum Potenzieren

Zum Potenzieren ist noch anzumerken, daß »pow« nicht mit »E« verwechselt werden sollte, denn »4E3« bedeutet nicht etwa ‹ 4³ ›, sondern ‹ 4 × 10³ ›. ‹ 4³ › wird in C als »pow( 4, 3 )« geschrieben.

Das Zeichen »^« heißt Zirkumflex. Es gibt in C auch einen Operator »^«, welcher in einigen Programmiersprachen zum Potenzieren verwendet wird. In C hat dieser Operator eine andere Bedeutung und darf daher nicht zum Potenzieren verwendet werden. Dieser Operator wird jedoch so selten gebraucht, daß seine Bedeutung hier nicht weiter erklärt werden soll. Es ist aber instruktiv, sich klar zu machen, daß das Potenzieren in einer Programmiersprache grundsätzlich auch mit einem Operator ausgedrückt werden kann. Die Festlegung, daß zum Multiplizieren zweier Zahlen ein Operator verwendet wird, aber zum Potenzieren eine Funktion aufgerufen wird, ist willkürlich. Da die Anzahl an Operatorzeichen begrenzt ist, gibt es aber viel mehr Funktionen als Operatoren.

Ausdrücke

Begriffshierarchie der Ausdrücke

Ausdruck
|
|
.--------------------------:---------------------------.---------------------------.
| | | |
Literal Operatorausdruck Aufruf Name
z.B.: 65 oder "abc" z.B.: -65 oder 2 + 3 | z.B.: errno
|
.------------------'------------------.
| |
Aufruf Aufruf
ohne Argumentausdruecke mit Argumentausdruecken
z.B.: f() z.B.: f( x )

Übungsfragen

? Verständnis von Fachbegriffen

Zu einer Funktion »f« wird erklärt: „Die Funktion »f« ergibt den Wert ihres Arguments.“. Welchen Wert hat dann »f( 3 )«?

Zu einer Funktion »m« wird erklärt: „Die Funktion »m« ergibt den Wert 4.“. Welchen Wert hat dann »m( 3 )«?

Zu einer Funktion »g« mit zwei Parametern wird erklärt: „Der Wert von »g« ist der Wert des ersten Arguments.“. Welchen Wert hat demnach »g( 3, 2 )«? Welchen Wert hat »g( g( 3, 2 ), 1 )«?

? Ausgabe

Sagen Sie die Ausgabe des folgenden Programms voraus, ohne es zu starten.

main.c

#include <stdio.h>
#include <math.h>
int main( void )
{ printf
  ( "%g\n", 2E3 ); }

? Ausgabe

Sagen Sie die Ausgabe des folgenden Programms voraus, ohne es zu starten.

main.c

#include <stdio.h>
#include <math.h>
int main( void )
{ printf
  ( "%g\n", pow( 2, 3 )); }

? Kugelvolumen

Das folgende C -Programm soll das Volumen einer Kugel mit einem Radius von 3 Metern berechnen. Das Volumen ‹ V › einer Kugel mit Radius ‹ r › beträgt ‹ 4/3 π r ³ ›. Wo steckt der Fehler in dem Programm? (Das in der nächsten Zeile verwendete mathematische Symbol ‹ ∧ › bedeutet „und“, das Symbol ‹ ⇒ › hat eine niedrigere Priorität als ‹ ∧ › und bedeutet „daraus folgt“.)

( V = 4/3 π r ³ )∧( r = 3 ) ⇒ V = 4/3 π r ³ ⇒ V = 4/3 π · 3³ = 4 π · 3² = 36 π ≈ 113,09733552923255658465516179806

main.c

#include <stdio.h>
#include <math.h>
int main( void )
{ printf
  ( "%g\n", 4/3 *( 4 * atan( 1 ))* pow( 3, 3 )); }

stdout

84.823

(In dem Programm wird die Kreiszahl ‹π› als »4 * atan( 1 )« geschrieben, da es in C die Kreiszahl ‹π› nicht als vordefinierte Konstante gibt. An dieser Stelle steckt der Fehler nicht.)

? Verträglichkeit von Parameterlisten und Argumentlisten

Welche der folgenden Paare von Parameterlisten und Ausdrucklisten sind verträglich?

Paar 0

Parameterliste

int a, double x

Argumentliste

2, 3

Paar 1

Parameterliste

int a, double x

Argumentliste

2.0, 3.0

Paar 2

Parameterliste

int a, double x

Argumentliste

2, "3"

Paar 3

Parameterliste

int a, double x, int b

Argumentliste

2, 3

? Dokumentation verstehen

Dokumentation einer Funktion mit zwei Parametern (nach N1570, überarbeitet und übersetzt)

7.12.7.3 Die Funktion »hypot«

Synopse

#include <math.h>
double hypot( double x, double y );

Beschreibung

Diese Funktion berechet die Quadratwurzel der Summe der Quadrate von x und y.

Ergebnis

Diese Funktion ergibt √( x² +y² ).

Wie viele Parameter hat die Funktion »hypot«?
Welche Namen haben die Parameter der Funktion »hypot«?
Welche Typen haben die Parameter der Funktion »hypot«?
Welchen Typ hat das Ergebnis der Funktion »hypot«?
Ändert sich der Wert eines Aufrufs der Funktion »hypot«, wenn die Argumente vertauscht werden?
Welchen Sinn könnte die Funktion »hypot« haben, wofür also könnte sie verwendet werden?

Übungsaufgaben

/ Ausgabe eines Ergebnisses

Schreiben Sie ein C -Programm, welches das Ergebnis eines Aufrufs der Funktion »hypot« ausgibt. Damit Sie überprüfen können, ob das Ergebnis mit der Beschreibung verträglich ist, sollten dabei zwei Argumentwerte verwendet werden, für die Sie das richtige Ergebnis schon kennen oder im Kopf ausrechnen können.

Ergänzungsaufgaben

/ Ermittlung des Maximums zweier Werte

Schreiben Sie ein C -Programm, in welchem mit der Funktion »fmax« das Maximum von 4 und 5 berechnet wird.

Anmerkungen *

Syntax von Parameterlisten *

Parameterliste

Parameterliste
    .----------------------------------.
    |                                  |
    |        .-----.    .------.       v
----'---.--->| Typ |--->| Name |---.---'--->
        ^    '-----'    '------'   |
        |            .-.           |
        '-----------( , )<---------'
                     '-'

Parameterliste (Beispiel)

double x, double y