Aufrufe mit mehreren Argumenten in C♯

Einleitendes Beispiel

Das folgende Programm zeigt die Berechnung des Produkts ‹ 2 × 3 › mit einem Operator.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( 2 * 3 ); }}

Protokoll

Neben den unären Operatoren (wie Vorzeichen) gibt es ja auch binäre Operatoren, welche zwei Operanden akzeptieren. Genauso gibt es auch binäre Aufrufe, welche zwei Argumente enthalten.

Das folgende Programm zeigt die Berechnung des Produkts ‹ 10 × 2 › mit einem Methodenaufruf.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Math.BigMul( 2, 3 ) ); }}

Protokoll

Henderson-Diagramm (nach Peter Henderson [Oxford/Southhampton])

        .
        :'.
   2 ---:  '.
        :    '.
        :BigMul:-- 6
   3 ---:    .'
        :  .'
        :.'
        '

Wie man sieht, ist es eine mehr oberflächliche Unterscheidung, ob eine Operation (ein Rechenschritt) nun mit einer Methode oder mit einem Operator geschrieben wird

In diesem Kapitel werden Methoden, wie »global::System.Math.BigMul« vorgestellt, ohne daß die als Beispiel gewählten speziellen Methoden dabei im Vordergrund stehen sollen. Es geht vielmehr darum, die allgemeine Möglichkeit von Aufrufen mit mehreren Argumenten vorzustellen. Deswegen werden an dieser Stelle die Anwendungsmöglichkeiten der Methode »global::System.Math.BigMul« nicht weiter vertieft. Es geht hier nicht um die speziellen Möglichkeiten der Anwendung der Methode »global::System.Math.BigMul«, sondern darum, wie es allgemein möglich ist, in Aufrufen mehrere Argumente zu verwenden. »global::System.Math.BigMul« dient lediglich als ein Beispiel dafür.

C♯

global::System.Math.BigMul( 2, 3 )

auf deutsch:

● „der Wert der Auswertung eines Aufrufs der Methode »global::System.Math.BigMul« mit den Argumentausdrücken »2« und »3«“

● „»global::System.Math.BigMul« von »2« und »3«“

● „das Produkt von Zwei und Drei“

Im allgemeinen spricht man »f(x,y)« als „f von x und y.“.

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.

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)

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

Ausdruckliste (Beispiel)

2, 3

Aufrufausdruck (Beispiel)

global::System.Math.BigMul( 2, 3 )

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

Eine parametrisierte Methode ist eine Methode mit mindestens einem Para̲meter.

Neue, erweiterte Syntax (vereinfacht)

Ausdruck
                .----------.
---.----------->| Literal  |---------------------------.---->
   |            '----------'                           |
   |            .----------.                           |
   '----------->| Name     |---------------------------'
   |            '----------'                           |
   |     .-.    .----------.                           |
   '--->( - )-->| Ausdruck |---------------------------'
   |     '-'    '----------'                           |
   |     .-.    .----------.                           |
   '--->( + )-->| Ausdruck |---------------------------'
   |     '-'    '----------'                           |
   |     .-.    .----------.    .-.                    |
   '--->( ( )-->| Ausdruck |-->( ) )-------------------'
   |     '-'    '----------'    '-'                    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( / )-->| Ausdruck |----'
   |            '----------'    '-'    '----------'    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( + )-->| Ausdruck |----'
   |            '----------'    '-'    '----------'    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( - )-->| Ausdruck |----'
   |            '----------'    '-'    '----------'    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( * )-->| Ausdruck |----'
   |            '----------'    '-'    '----------'    |
   |            .--------.                             |
   '----------->| Aufruf |-----------------------------'
                '--------'
Aliaseintrag
   .-------------------------.
   |    .--------.    .-.    v    .------. 
---'--->| global |-->( : )---'--->| Name |--->
        '--------'    '-'         '------'
Name
   .-----------------------.
   |    .------.    .-.    v    .------------. 
---'--->| Name |-->( . )---'--->| Bezeichner |--->
        '------'    '-'         '------------'
Aufruf
    .--------------.     .-.     .---------------.     .-.    
--->| Aliaseintrag |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '--------------'     '-'     '---------------'     '-'
Ausdruckliste
   .---------------------------.            
   |        .----------.       v
---'---.--->| Ausdruck |---.---'--->
       ^    '----------'   |
       |        .-.        |
       '-------( , )<------'
                '-'

Semantik

Bei der Auswertung eines Aufrufausdrucks werden zuerst alle Argumentausdrücke ausgewertet. Dabei wird von links nach rechts vorgegangen, das erste Argument wird also vor dem zweiten ausgewertet.

In dem folgenden Programm wird beispielsweise der Teilausdruck »1+2« vor dem Teilausdruck »3+4« ausgewertet.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Math.BigMul( 1+2, 3+4 ) ); }}

Protokoll

Anschließend wird die durch den Methodennamen angegebenen Methode mit den im vorigen Schritt ermittelten Werten der Argumente verbunden. Solch eine Verbindung einer Methode mit konkreten Argumentwerten zur Laufzeit (nicht bloß mit den Argumentausdrücken ) wird auch eine Inkarnation (der Methode) genannt, genauso wird auch die Herstellung dieser Verbindung genannt.

Eine Inkarnation der Methode »global::System.Math.BigMul«

»global::System.Math.BigMul(3.0,7.0)

Die Inkarnation wird dann ausgeführt (also als Programm gestartet), diese Ausführung der Inkarnation wird hier auch Methodenoperation genannt.

Dokumentation

Dieser Abschnitt stellt die Dokumentation der Methode »global::System.Math.BigMul« als Beispiel der Dokumentation einer Methode mit mehreren Parametern vor. Mehrere Parameterbeschreibungen werden in der Dokumentation in den runden Klammern jeweils durch ein Komma getrennt.

»msdn.microsoft.com/library/system.math.bigmul« (vereinfacht und übersetzt): Namensraum »global::System«; Klasse »Math«; Lemma »BigMul«; Proklamation; int BigMul( int a, int b ); Prosa; Ergibt das Produkt der beiden Argumentwerte.

Ein Aufruf der Methode »global::System.Math.BigMul« ergibt das Produkt des ersten Argumentwertes und des zweiten Argumentwertes (also das erste Argument „mal“ das zweite Argument). Die voranstehende Dokumentation stellt klar, daß zwei Argumente erwartet werden und daß ein Ergebnis geliefert wird.

In der Dokumentation finden sich die Parameter in den runden Klammern hinter dem Methodennamen beschrieben, diese Liste der Parameter wird auch Parameterliste genannt (es handelt sich eigentlich nicht um eine Liste der Parameter selber, sondern von Beschreibungen der Parameter).

Parameterliste

int a, int b

Es sind nicht nur Funktionen mit bis zu zwei Parametern möglich, vielmehr können Funktionen beliebig viele Parameter haben.

Insgesamt ist ein Parameter also nun gekennzeichnet durch

die Methode, zu der er gehört,
seine Position in der Liste aller Parameter,
seinen Namen und,
seinen Typ.

Die Prosa der Dokumentation einer Methode beschreibt auch, wie der Wert des Aufrufs einer Methode festgelegt wird. Sie gibt also auch die Semantik eines Aufrufs dieser Methode an. Der Wert des Aufrufs einer Methode 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 Methode von den Werten der Argumente und von anderen Umständen abhängt.

Im Falle der Methode »global::System.Math.BigMul« wird die Semantik beispielsweise durch den Text „Ergibt das Produkt der beiden Argumentwerte.“ aus ihrer Dokumentation bekannt gemacht.

Regeln für das Schreiben von Aufrufen

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

Der Typ jedes Arguments muß wie beim Aufruf einer Methode mit einem Parameter beschrieben zum Typ des entsprechenden Parameters passen.

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 Methode wird dann der Wert jedes Parameters durch den (in den Parametertyp gewandelten) Wert des entsprechenden Argumentausdrucks festgelegt. Der Aufruf »global::System.Math.BigMul( 2, 3 )« legt beispielsweise den Wert »2« für den ersten Parameter und den Wert »3« für den zweiten Parameter fest. Dementsprechend bedeutete dieser Aufruf dann ‹ 2 × 3 ›.

Verwendung von Parameternamen

Einem Argument kann beim Aufruf einer Methode noch der Name des zugehörigen Parameters, durch einen Doppelpunkt getrennt, vorangestellt werden.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Math.BigMul( a: 1+2, b: 3+4 ) ); }}

Protokoll

Neue, erweiterte Syntax (vereinfacht)

Aufruf
    .--------------.     .-.     .---------------.     .-.    
--->| Aliaseintrag |--->( ( )--->| Ausdruckliste |--->( ) )--->
    '--------------'     '-'     '---------------'     '-'
Ausdruckliste
   .-------------------------------------------------------------.
   |       .-----------------------------.                       |
   |       |    .----------.      .-.    v    .----------.       v
---'---.---'--->| Bezeicher |--->( : )---'--->| Ausdruck |---.---'--->
       ^         '----------'     '-'         '----------'   |
       |        .-.                                          |
       '-------( , )<----------------------------------------'
                '-'

In diese Fall ist die Reihenfolge der Parameternamen beliebig.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Math.BigMul( b: 3+4, a: 1+2 ) ); }}

Protokoll

Oben gibt des erste Argument nun den Wert für den zweiten Parameter an!

Die Parameternamen »a« und »b« sind relativ nichtssagend. Oft sind Parameternamen aber auch erklärende, sprechende Namen und können dann als Lesehilfe dienen. Insofern ist die Kennzeichnung von Argumenten mit Parameternamen, gerade bei Aufrufen mit mehreren Argumenten, empfehlenswert.

Ausdrücke (Zusammenfassung)

Ein Ausdruck ist

ein Literal,
ein Name,
eine Operatorausdruck oder
ein Aufruf.

Begriffshierarchie der Ausdrücke

                                                           Ausdruck
                                                              |
                                                              |
           .--------------------------:-------------------------------------.-------------------------------------.
           |                          |                                     |                                     |
        Literal                Operatorausdruck                           Aufruf                                Name
 z.B.: 65 oder "abc"         z.B.: -65 oder 2 + 3                           |                        z.B.: global::System.Math.PI
                                                                            |
                                       .------------------------------------'------------------------------------.       
                                       |                                                                         |
                                     Aufruf                                                                   Aufruf
                           ohne Argumentausdruecke                                                    mit Argumentausdruecken
               z.B.: global::Microsoft.JScript.MathObject.random()                            z.B.: global::System.Math.BigMul( 2, 3 )

Beispiel Kennzahlen von Schriftzeichen

Die Methode »global::System.Char.ConvertToUtf32« ordnet einem Schriftzeichen, das durch eine Zeichenfolge vom Typ »string« und einem Versatz vom Typ »int« gegeben ist, eine Kennzahl zu.

Der Versatz gibt die Position des Schriftzeichens in der Zeichenfolge an. Dabei hat das erste Zeichen den Versatz 0, das zweite Zeichen der Versatz 1 und so weiter.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Char.ConvertToUtf32( "A", 0 )); }}

Protokoll

Übungsfragen _

? Reihenfolge von Operationen _

Eine Methodenoperation (ein Rechenschritt) ist durch eine Methode und Werte für alle ihre Parameter bestimmt.

Bei der Auswertung des weiter unten stehenden Ausdrucks, werden die folgenden vier Operationen (Rechenschritte) ausgeführt.

A) »global::System.Math.BigMul( 7, 22 )«,
B) »global::System.Math.Abs( 7 )«,
C) »global::System.Int32.Parse( "22" )« und
D) »"2" + "2"«.

Diese vier Operationen werden aber bei der Auswertung des ganzen Ausdrucks nicht unbedingt auch in dieser Reihenfolge „A, B, C, D“ ausgeführt. In welcher Reihenfolge werden sie ausgeführt?

Ausdruck

global::System.Math.BigMul
( global::System.Math.Abs( 7 ), global::System.Double.Parse( "2." + "2" ))

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Math.BigMul
      ( global::System.Math.Abs( 7 ), global::System.Int32.Parse( "2" + "2" )) ); }}

Protokoll

? Verträglichkeit von Dokumentation und Aufruf

Ist der folgende Aufruf mit der darüberstehenden Dokumentation verträglich (in dem Sinne, daß er als Ausdruck in einem Programm vorkommen kann, ohne eine Fehlermeldung hervorzurufen)?

»msdn.microsoft.com/library/system.math.round« (vereinfacht und übersetzt)

Namensraum »global::System«

Klasse »Math«

Lemma »Round«

Proklamation

double Round( double, int )

Prosa

Ergibt die Rundung des ersten Arguments auf die durch das zweite Argument angegebene Zahl von Nachkommastellen.

Aufruf von »global::System.Math.Round«

global::System.Math.Round( 0, 0 )

? Verträglichkeit von Parameterlisten und Argumentlisten _

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

(Das heißt: Welche der folgenden Argumentlisten sind beim Aufruf einer Methode möglich, deren Dokumentation die darüberstehende Parameterliste hat?)

Paar 0

Parameterliste

int, double

Argumentliste

2, 3

Paar 1

Parameterliste

int, double

Argumentliste

2.0, 3.0

Paar 2

Parameterliste

int, double, int

Argumentliste

2, 3

? Dokumentation verstehen

»msdn.microsoft.com/library/system.math.pow« (vereinfacht und übersetzt): Namensraum »global::System«; Klasse »Math«; Lemma »Pow«; Proklamation; double Pow( double, double ); Prosa; Ergibt die Potenzierung des ersten Argumentwerts (als Basis) mit dem zweiten Argumentwert (als Exponent).

Wie viele Parameter hat die Methode »global::System.Math.Pow«?
Welche Typen haben die Parameter dieser Methode?
Welchen Typ hat ein Aufruf dieser Methode?
Könnte sich der Wert eines Aufrufs dieser Methode ändern, wenn die beiden Argumente vertauscht werden?

»pow(a,n)« kann auch als „a hoch n“ gesprochen werden.

? 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

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( 4/3 * global::System.Math.PI * global::System.Math.Pow( 3, 3 )); }}

Protokoll

84.8230016469244

? Verständnis von Fachbegriffen ⃗

Zu einer (hypothetischen) Methode mit zwei Parametern und dem Namen »k« wird erklärt: „Der Wert von »k« ist der Wert des ersten Arguments.“. Welchen Wert hat demnach »k( 3, 2 )«? Welchen Wert hat »k( k( 5, 1 ), k( 4, 9 ))«?

Übungsaufgaben

/ Inkarnation eines Syntaxdiagramms

Schreiben Sie eine Inkarnation der Kategorie »Ausdruck« des folgenden Syntaxdiagramms. mit dem Aliaseintrag »global::System.Math.BigMul« und den Ausdrücken »global::System.Math.Cos( 0 )« und »22« (in dieser Reihenfolge).

Aufrufausdruck (Syntaxdiagramm)

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

Die Lösung soll auf einer von Leerzeilen umgebenden Zeile für sich stehen.

/ Ausgabe eines Ergebnisses

Schreiben Sie ein C♯ -Programm, welches das Ergebnis eines Aufrufs der Methode »global::System.Math.Pow« ausgibt.

Verwenden Sie darin möglichst Argumentwerte, die es Ihnen erlauben, das richtige Ergebnis auch im Kopf auszurechnen, um dann sehen zu können, ob die Methode auch tatsächlich das richtige Ergebnis liefert.

Reserveaufgaben _

/ Ermittlung des Maximums zweier Werte _

Schreiben Sie ein C♯ -Programm, in welchem mit der Methode »global::System.Math.Max« das Maximum von 4 und 5 berechnet wird.

»msdn.microsoft.com/library/system.math.max« (vereinfacht und übersetzt): Namensraum »global::System«; Klasse »Math«; Lemma »Max«; Proklamation; int Max( int, int ); Prosa; Ergibt den kleinsten Wert, der nicht kleiner als bei Argumentwerte ist.