Argumente in C♯
Einführendes Beispiel
Das folgende Beispiel zeigt die Anwendung des schon behandelten unären Operators »-« auf dem Operandenausdruck »( 3m )«.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( -( 3m ) ); }}global::System.Console.Out-3
Im folgenden Programm wurde der Operator »-« durch den Namen »global::System.Decimal.Negate« ersetzt.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Decimal.Negate( 3m )); }}global::System.Console.Out-3
Das Ergebnis von »global::System.Decimal.Negate« ist dem Ergebnis des Operators »-« gleich. Allerdings sind die runden Klammern um »3m« bei der Verwendung des Namens an Stelle des Operators notwendig, während sie bei Verwendung des Operators auch hätten entfallen können.
Bei »global::System.Decimal.Negate« handelt es sich ebenfalls um eine Methode, nur sind die Klammern des Aufrufausdrucks diesmal nicht leer (wie bei den bisher behandelten Aufrufausdrücken), sondern enthalten einen Operandenausdruck. Der gesamte Aufrufausdruck ist also »global::System.Decimal.Negate( 3m )«.
- Ein Aufrufausdruck
global::System.Decimal.Negate( 3m )
Aussprache eines Aufrufausdrucks
Die runde Klammer auf »(« wird im Deutschen (in der Mathematik) bei Verwendung der Funktionsschreibweise meist als „von“ gesprochen. So ist »global::System.Decimal.Negate( 3m )« „Negate von Drei“ oder „das Negative von Drei“ (Man kann den langen Namen »global::System.Decimal.Negate« beim Aussprechen ruhig abkürzen, solange dadurch keine Mißverständnisse zu befürchten sind). Den Ausdruck »cos( 0 )« kann man beispielsweise als „Kosinus von Null“ aussprechen. Ausführlicher nennt man »cos( 0 )« „der Aufruf der Methode »cos« mit dem Argument(wert) »0«“.
Man kann sich den Aufruf »global::System.Decimal.Negate( 3m )« auch als Frage veranschaulichen: „Was ist das Negative von »3«?“ – er antwortet dann mit »-3«.
Syntax
Das folgende Syntaxdiagramm erweitert das bisherige Syntaxdiagramm für Aufrufausdrücke um die Möglichkeit eines in die Klammern geschriebenen Ausdrucks.
- Aufrufausdruck (Syntaxdiagramm)
Aufrufausdruck
.-------------------.
.---------------. .-. | .----------. v .-.
--->| Aliaseintrag |--->( ( )---'--->| Ausdruck |---'--->( ) )--->
'---------------' '-' '----------' '-'
Der Argumentausdruck
Ein 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 Argumentwert
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 einem Argument. Dann muß dem Zusammenhang entnommen werden, ob damit der Argumentausdruck oder der Argumentwert gemeint ist – manchmal sind auch beide Interpretationen gleichzeitig möglich.
Erklärung zur Bedeutung von Ausdrücken
Wir hatten Ausdrücke bereits als Quelltexte kennengelernt, welche man in den Ausdruckrahmen einsetzen kann. Danach konnten wir Ausdrücke auch als das charakterisieren, was man als Operand eines Operators schreiben kann. Nun können wir Ausdrücke auch noch dadurch charakterisieren, daß sie als Argumente in Aufrufausdrücken verwendet werden können. Wenn man Argumente aber auch als eine Art von Operanden ansieht, dann ist es nicht nötig, sie ausdrücklich zu erwähnen, und wir können dann weiterhin einfach sagen: Ein Ausdruck ist etwas, das in den Ausdruckrahmen eingesetzt werden oder als Operand verwendet werden kann.
Deterministische Methoden
Eine Methode, welche man mit einem Argument aufrufen kann, und welche einen Wert als Ergebnis liefert, der durch diese Methode und einen eventuellen Argumentwert bestimmt ist, nennt man auch eine deterministische Methode.
»global::System.Decimal.Negate« ist ein Beispiel für eine deterministische Methode, weil sich bei gleichem Aufruf auch der gleicher Wert ergibt, während die Methoden »global::System.AppDomain.GetCurrentThreadId()« nicht deterministisch ist, da sie auch bei gleicher Schreibweise des Aufrufs unterschiedliche Werte liefern kann.
Deterministische Methoden, die mit einem Argument aufgerufen werden, ähneln den Funktionen (Abbildungen) der Mathematik, während nicht-deterministische Methode in der Schulmathematik keine Entsprechung haben.
Die Auswertung: Erster Schritt: Die Inkarnation
Wenn eine Methode auf ein Argument angewendet wird, dann wird eine Verbindung zwischen der Methode und dem Wert des Arguments hergestellt, die auch als Aktivierungsverbund oder als eine Inkarnation der Methode bezeichnet wird. (Auch bei Methoden ohne Argument gibt es eine entsprechende Vorbereitung zum Start der Methode, die wir hier ebenfalls als „Inkarnation“ bezeichnen.)
Im Ausdruck »global::System.Decimal.Negate( 3m )« ist die Verbindung zwischen dem Methodennamen und dem Argumentwert bereits für den Programmierer sichtbar, aber bei der Ausführung des Programms muß der Computer sie bei der Auswertung dieses Ausdrucks noch einmal neu anlegen. Dies ist die Inkarnation der Methode. Das Wort „Inkarnation “ bedeutet hier den Prozeß des Zusammenfügens zweier Informationen und auch dessen Ergebnis, also die Verbindung zwischen Methode und Argumentwert.
Die Auswertung: Zweiter Schritt: Die Operation
Nachdem die Inkarnation hergestellt wurde, wird sie dann als eine Operation ausgeführt. Eine Operation ist ein Vorgang der Datenverarbeitung, der ein Ergebnis liefern kann, wie hier den Wert »-3m«.
Eine Methode alleine ist im allgemeinen noch keine Operation, beispielsweise kann die Methode »global::System.Decimal.Negate( 3m )« alleine (ohne Inkarnation) noch nicht ausgeführt werden, weil ihr ja noch ein Argumentwert fehlt.
Anwendung
Wenn eine Methode mit einem Argument zusammen aufgerufen wird, dann sagt man auch, daß die Methode auf dieses Argument angewendet werde. Man nennt »global::System.Decimal.Negate( 3m )« also beispielsweise „die Anwendung der Methode »global::System.Decimal.Negate« auf den Wert »3m«“. Damit kann sowohl der Ausdruck »global::System.Decimal.Negate( 3m )« als auch dessen Auswertung gemeint sein.
Argumentausdrücke
Die Methode »global::System.Math.Floor« ergibt die Abrundung des Wertes ihres Arguments.
Wir zeigen ein Beispiel mit einem Operatorausdruck als Argumentausdruck.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 2 + 3.5 )); }}global::System.Console.Out5
Wir zeigen ein Beispiel mit einem Namensausdruck als Argumentausdruck.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( global::System.Math.PI )); }}global::System.Console.Out3
Wir zeigen ein Beispiel mit einem Aufrufausdruck als Argumentausdruck.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor
( global::Microsoft.JScript.MathObject.random() )); }}global::System.Console.Out0
Weiteres Beispiel
Das folgende Programm zeigt den C♯ -Ausdruck, welcher der deutschen Nominalphrase „Der Sinus von 2“ entspricht.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Sin( 2.0 )); }}global::System.Console.Out0.909297426825682
Übungsfragen
? Ausdrücke lesen
Was ist der Argumentausdruck in dem Aufrufausdruck »global::System.Math.Floor( 3.2 )«?
Welchen Wert hat der Aufrufausdruck »global::System.Math.Floor( 3.2 )«?
Welchen Typ hat der Aufrufausdruck »global::System.Math.Floor( 3.2 )«?
? Ausdrücke lesen (1)
Was ist der Argumentausdruck in dem Aufrufausdruck »global::System.Math.Floor( global::Microsoft.JScript.MathObject.random() * 4 )«?
Welche Werte kann dieser Argumentausdruck haben?
Welche Werte kann der Aufrufausdruck »global::System.Math.Floor( global::Microsoft.JScript.MathObject.random() * 4 )« haben?
Sind diese Wert alle annähernd gleich wahrscheinlich? (Zur Beantwortung dieser Frage kann angenommen werden, daß »global::Microsoft.JScript.MathObject.random()« alle Werte zwischen 0 und 1−2⁻⁵³ mit gleicher Wahrscheinlichkeit liefert.)
? Ermittlung von Operanden ⃗
Kann es eine Funktion »f« geben, die wie in den folgenden Beispielen gezeigt, den linken Operanden ihres Argumentausdrucks ergibt?
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( f( 1 + 3 )); }}global::System.Console.Out1
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( f( 2 + 2 )); }}global::System.Console.Out2
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( f( 3 + 1 )); }}global::System.Console.Out3
Operanden und Argumente *
Man kann den Argumentausdruck auch als den Operanden des Aufrufs ansehen und den Rest (also den Methodennamen und die runden Klammern) als einen unären Zirkumfixoperator. Diese Sichtweise ist aber unüblich, zumal der Operator dann auch oft aus relative vielen einzelnen lexikalischen Einheiten bestünde. Trotzdem gilt alles, was wir hier über Operanden sagen im Regelfall auch für Argumente. Daher ist es im allgemeinen eine Vereinfachung, wenn man ein Argument als eine Art von Operand ansieht, damit man nicht immer von „Operanden und Argumenten “ sprechen muß.
- Ein Aufrufausdruck zerlegt in Operator und Operand
Operand
|
vglobal::System.Decimal.Negate( 3m )
------------------------------ -^ ^
'-------------------'
|
Operator
Übergabe des Argumentwerts *
Man kann sich den Sinn eines Arguments auch so erklären: Die Methode »global::System.Decimal.Negate« benötigt noch Informationen, um ihre Arbeit tun zu können, und diese Informationen werden durch den Wert des Arguments geliefert. Das Argument enthält die Information, welche die Methode verarbeiten soll.
Da beim Aufruf einer Methode der Wert des Argumentausdrucks zur Laufzeit zusammen mit der Kontrolle (über den Computer) an die aufgerufene Methode übergeben wird, spricht man auch von der Übergabe des Argumentwertes oder sagt, der Argumentwert werde an die aufgerufene Methode übergeben.
- Hauptprogramm und »negateExact«
Hauptprogramm
|
|
| Übergabe der Kontrolle
| und des Wertes 3m
'------------------.
|
V
.---------------.
| Negate |
'---------------'
|
|
.<-----------------'
| Rueckgabe der Kontrolle
| und des Wertes -3m
|
vHauptprogramm
Das folgende Diagramm stellt dieselbe Situation mit etwas allgemeineren Begriffen vor.
- Übergabe und Rückgabe der Kontrolle zur Laufzeit
Hauptprogramm
|
|
| Übergabe der Kontrolle
| und des Argumentwertes
'------------------.
|
V
.---------------.
| Unterprogramm |
'---------------'
|
|
.<-----------------'
| Rueckgabe der Kontrolle
| und des Ergebniswertes
|
vHauptprogramm
Ein- und Ausgabe bei Methoden *
Man kann eine Methode wie »global::System.Decimal.Negate« auch mit einer Backmaschine vergleichen, bei der man – vereinfacht gesagt – Mehl hinein gibt und Brot heraus bekommt: bei »global::System.Decimal.Negate« gibt man eine Zahl hinein und bekommt die negative Zahl heraus.
Insofern kann man eine Methode wie ein Maschine sehen, in eine Information eingegeben werden kann, und die dann eine andere Information dazu ausgibt. Gibt man in »global::System.Decimal.Negate« beispielsweise die Zahl »3m«, so kommt als Ausgabe die Zahl »-3m« heraus.
- »global::System.Decimal.Negate« als Maschine mit einer Eingabe und einer Ausgabe
"Eingabe" "Ausgabe" (nur vergleichsweise Bezeichnungen)
.-------------------------------.
3m ---> | global::System.Decimal.Negate |---> -3m
'-------------------------------'Übergabe Rückgabe (korrekte Bezeichnungen)
Freilich spricht man aber in diesem Fall normalerweise nicht von „eingeben“ sondern von „übergeben“ und auch nicht von „ausgeben“, sondern von „zurückgeben“.
Auch wenn in diesem Abschnitt zu Lehrzwecken einmal von der „Eingabe“ und der „Ausgabe“ bei einer Methode gesprochen wurde, sollte man dafür normalerweise von der „Übergabe eines Argumentwertes an eine Methode“ und der „Rückgabe eines Ergebniswertes durch eine Methode“ sprechen.
Semantik eines Argumentwertes *
Die Bedeutung eines bestimmten Argumentwertes für die Auswertung des Aufrufausdrucks wird durch die aufgerufene Methode beziehungsweise ihre Dokumentation jeweils individuell festgelegt.
Beispiel »global::System.Math.Floor« *
Um das Negative einer Zahl zu berechnen, ist eigentlich keine spezielle Methode nötig, da es ja dafür bereits den unären Operator »-« gibt. Es gibt aber auch Methoden, die mit einem Argumentausdruck aufgerufen werden können und zu denen es keinen entsprechenden Operator gibt. Um auch für solche eine Methode ein Beispiel zu haben, wird in diesem Abschnitt die Methode »global::System.Math.Floor« als Beispiel vorgestellt.
Der Boden (die Abrundung, englisch “floor ” /flɔɚ/) einer Zahl ist die größte ganze Zahl, welche nicht größer als die Zahl ist. So haben die Zahlen 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8 und 2.9 beispielsweise alle den Boden 2.
- Auflistung ausgewählter Zahlen und ihres Bodens
Zahl Boden
1,50 1
1,75 12,00 2
2,25 2
2,50 2
2,75 23,00 3
3,25 3
So bedeutet der Aufrufausdruck »global::System.Math.Floor( 2.7 )« den „Boden von »2.7«“: Hier ist »global::System.Math.Floor« der Methodenname und »2.7« der Argumentausdruck des Aufrufausdrucks.
Der Wert des Aufrufs wird durch den Methodennamen »global::System.Math.Floor« und den Wert des Operanden »2.7« gemeinsam bestimmt.
Das folgende Beispiel zeigt, daß der Wert des Aufrufausdrucks für den Argumentwert »2.7« gleich »2.0« ist.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 2.7 )); }}global::System.Console.Out2.0
Das folgende Beispiel zeigt, daß der Wert des Aufrufausdrucks für den Argumentwert »3.7« gleich »3.0« ist.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 3.7 )); }}global::System.Console.Out3.0
Das folgende Beispiel zeigt, daß der Wert des Aufrufausdrucks für den Argumentwert »2.7« erneut gleich »2.0« ist.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 2.7 )); }}global::System.Console.Out2.0
Diese Beispiele veranschaulichen, daß die Methode »global::System.Math.Floor« deterministisch ist, ihre Ergebnis ist also durch den Argumentwert bestimmt.
In diesem Kapitel werden Methodennamen, wie »global::System.Math.Floor« oft vorgestellt, ohne daß die als Beispiel ausgewählten speziellen Methoden dabei im Vordergrund stehen sollen. Es geht vielmehr darum, das allgemeine Phänomen der Methoden vorzustellen. Deswegen werden an dieser Stelle die Anwendungsmöglichkeiten der Methode »global::System.Math.Floor« nicht weiter vertieft. Es geht hier nicht um die speziellen Möglichkeiten der Anwendung der Methode »global::System.Math.Floor«, sondern darum, wie es allgemein möglich ist, Methodennamen zu verwenden. »global::System.Math.Floor« dient dann lediglich als ein Beispiel dafür.
Die Methode »global::System.Math.Floor« ist allerdings nicht nur als Beispiel dienlich; diese spezielle Methode zum Abrunden wird auch in der Anwendung der Programmiersprache C♯ öfter verwendet.
Obwohl die Methode »global::System.Math.Floor« ja immer ganze Zahlen liefert, ist der Datentyp eines Aufrufs dieser Methode stets »double« und nicht etwa, wie man glauben könnte, »int«. Dadurch ist es möglich auch noch Ergebnisse zu liefern, die für den Datentyp »int« zu groß wären. Dies verdeutlicht, daß der Datentyp »int« nicht mit “integer ” (also einer ganzen Zahl) gleichzusetzen ist.
Operatorausdrücke als Argumentausdrücke *
Da ein Argumentausdruck ein ein im Prinzip beliebiger Ausdruck sein kann, darf auch ein Operatorausdruck (wie unten »2 + 3.5«) als Argumentausdruck verwendet werden. Der Argumentwert ist dann der Wert des verwendeten Operatorausdrucks.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 2 + 3.5 )); }}global::System.Console.Out5
Bei der Auswertung solch eines Aufrufs muß zuerst der Operatorausdruck ausgewertet werden. Dieser hat in dem obigen Beispiel den Wert »5.5«. Dann wird die Inkarnation »global::System.Math.Floor( 5.5 )« hergestellt und ausgeführt; sie liefert schließlich das Ergebnis »5.0«.
Die Reihenfolge der Auswertung ist hier also genau anders herum als die Reihenfolge im Quelltext. Im Quelltext steht zuerst »floor« und dann »+«. Ausgewertet wird zuerst »+« und dann »floor«.
Operatorausdrücke als Argumentausdrücke veranschaulichen noch einmal den Unterschied zwischen Argumentausdrücken und Argumentwerten.
In den beiden folgenden Programmen ist der Argumentausdruck einmal »5.5« und einmal »2 + 3.5«, der Argumtwert ist aber in beiden Fällen derselben.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 5.5 )); }}global::System.Console.Out5
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 2 + 3.5 )); }}global::System.Console.Out5
Für das Ergebnis einer Auswertung eines Methodenaufrufs kommt es nur auf den Argumentwert an, nicht auf den Argumentausdruck.
Das folgende Diagramm zeigt noch einmal die einzelnen Schritte der Auswertung von »global::System.Math.Floor( 2 + 3.5 )«.
- Schritte bei der Auswertung von »global::System.Math.Floor( 2 + 3.5 )«
2 + 3.5
1.) | Operationsvorgang
v5.5 Operationsprodukt
2.) | Inkarnationsvorgang
v (Einsetzen des Argumentwertes)global::System.Math.Floor( 5.5 ) Inkarnationsprodukt
3.) | Operationsvorgang
v5 Operationsprodukt
Ein Inkarnationsvorgang ist das Einsetzen von Werten für Operanden (damit sind hier auch Argumente gemeint). Beispielsweise das Einsetzen des Wertes »5.5« für den Argumentausdruck »2 + 3.5«.
Ein Inkarnationsprodukt ist das Ergebnis eines Inkarnationsvorganges, beispielsweise »global::System.Math.Floor( 5.5 )«. In einem Inkarnationsprodukt sind alle Operanden (einschließlich der Argumenten) Werte. Falls ein Methodenaufruf (wie beispielsweise »global::Microsoft.JScript.MathObject.random()«) gar keine Ausdrücke enthält, so kann dieser bereits so wie er ist als Inkarnationsprodukt angesehen werden.
Falls nur von einer „Inkarnation “ gesprochen wird, so ist damit – je nach Zusammenhang – entweder der Vorgang oder das Produkt einer Inkarnation gemeint.
Ein Operationsvorgang ist die Ausführung eines Inkarnationsproduktes, beispielsweise die Auswertung von »global::System.Math.Floor( 5.5 )«.
Ein Operationsprodukt ist das Ergebnis eines Operationsvorgangs, beispielsweise der Wert »5« als Produkt der Auswertung von »global::System.Math.Floor( 5.5 )«.
Falls nur von einer „Operation “ gesprochen wird, so ist damit der Vorgang einer Operation gemeint.
Namen als Argumentausdrücke *
Das folgende Beispiel zeigt, daß auch ein Name (hier »global::System.Math.PI«) als Argumentausdruck vorkommen kann. Der Argumentwert ist dann der Wert des verwendeten Namens.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( global::System.Math.PI )); }}global::System.Console.Out3
Das folgende Diagramm zeigt die einzelnen Schritte bei der Auswertung von »global::System.Math.Floor( global::System.Math.PI )«.
- Schritte bei der Auswertung von »global::System.Math.Floor( global::System.Math.PI )«
global::System.Math.PI
1.) | Vorgang des Auslesen
v des Wertes des Namens3.141592653589793 Ausgelesener Wert
2.) | Inkarnationsvorgang
v (Einsetzen des Argumentwertes)global::System.Math.Floor( 3.141592653589793 ) Inkarnationsprodukt
3.) | Operationsvorgang
v3 Operationsprodukt
Aufrufausdrücke als Argumentausdrücke *
Das folgende Beispiel zeigt, daß auch ein Aufrufausdruck (hier »global::Microsoft.JScript.MathObject.random()«) als Argumentausdruck vorkommen kann. Der Argumentwert ist dann der Wert einer Auswertung des als Argumentausdrucks verwendeten Aufrufausdrucks.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( global::Microsoft.JScript.MathObject.random() )); }}global::System.Console.Out0
Das voranstehende Beispie; zeigt, daß ein Argumentwert auch ein Laufzeitwert sein darf. Durch Lesen des Quelltextes kann man den Argumentwert also gar nicht erfahren, man sieht nur den Argumentausdruck! Auch dies verdeutlicht wieder den Unteschied zwischen Argumentwert und Argumentausdruck.
Das folgende Diagramm zeigt die einzelnen Schritte bei der Auswertung von »global::System.Math.Floor( global::Microsoft.JScript.MathObject.random() )«. Da der Wert einer Auswertung von »global::Microsoft.JScript.MathObject.random()« von der Auswertung abhängt, können wir hier nur einen möglichen Wert als Beispiel herausgreifen.
- Schritte bei der Auswertung von »global::System.Math.Floor( global::Microsoft.JScript.MathObject.random() )«
global::Microsoft.JScript.MathObject.random()
1.) | Operationsvorgang zur
v angegebenen Inkarnation0.876599014493339 Operationsergebnis (Beispiel)
2.) | Inkarnationsvorgang
v (Einsetzen des Argumentwertes)global::System.Math.Floor( 0.876599014493339 ) Inkarnationsprodukt
3.) | Operationsvorgang
v0 Operationsprodukt
Argumentausdrücke mit Aufrufen und Operatoren *
Es ist auch möglich, daß ein Argumentausdruck Namen, Operatoren und Aufrufausdrücke gleichzeitig enthält.
Wir hatten bei dem folgenden Beispielprogramm schon gesehen, daß die Ausgabe immer »0« ist.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( global::Microsoft.JScript.MathObject.random() )); }}global::System.Console.Out0
Da es langweilig ist, wenn die Ausgabe immer gleich ist, zeigen wir das folgende Beispielprogramm, welches nun sowohl einen Methodennamen als auch einen Operator im Argumentausdruck enthält.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Math.Floor( 3 * global::Microsoft.JScript.MathObject.random() )); }}global::System.Console.Out0
global::System.Console.Out1
global::System.Console.Out2
Das direkt obenstehende Programm kann nun bei jedem weiteren Start einen anderen Wert als beim vorherigen Start ausgeben.
Das voranstehende Beispiel zeigt, daß ein Argumentwert auch ein Laufzeitwert (also ein vor der Ausführung des Programms noch nicht bekannter Wert) sein darf. Durch Lesen des Quelltextes kann man den Argumentwert also gar nicht erfahren, man sieht nur den Argumentausdruck! Auch dies verdeutlicht wieder den Unteschied zwischen Argumentwert und Argumentausdruck.
Auch hier hängen einige Werte nun wieder von der Auswertung ab und können deswegen im folgenden nur durch willkürlich ausgewählte Beispiele dargestellt werden.
- Mögliche Schritte bei der Auswertung von »global::System.Math.Floor( 3 * global::Microsoft.JScript.MathObject.random() )«
global::Microsoft.JScript.MathObject.random() Inkarnationsprodukt
1.) | Vorgang der Ermittlung
v einer Zufallszahl0.570273922904462 Zufallszahl (zwischen 0 und 1)
2.) | Inkarnationsvorgang
v (Einsetzen der Operandenwerter)3 * 0.570273922904462 Inkarnationsprodukt
3.) | Operationsvorgang
v1.71082176871339 Operationsprodukt (zwischen 0 und 3)
4.) | Inkarnationsvorgang
v (Einsetzen des Argumentwertes)global::System.Math.Floor( 1.71082176871339 ) Inkarnationsprodukt
5.) | Operationsvorgang
v1 Operationsprodukt (0, 1 oder 2)
Das folgende Diagramm zeigt den Wertebereich des Ausdrucks »global::Microsoft.JScript.MathObject.random()« mit Hilfe von Nummernzeichen an.
Die Werte sind darin alle gleich wahrscheinlich.
- Wertebereich des Ausdrucks »global::Microsoft.JScript.MathObject.random()«
global::Microsoft.JScript.MathObject.random()
0 0.25 0.5 0.75 1.0 1.25 1.5 1.75 2.0 2.25 2.5 2.75 3.0 3.25 3.5 3.75 4.0
| ' ' ' | ' ' ' | ' ' ' | ' ' ' |####################
Das folgende Diagramm zeigt den Wertebereich des Ausdrucks »3 * global::Microsoft.JScript.MathObject.random()« mit Hilfe von Nummernzeichen an.
Die Werte sind darin weiterhin gleich wahrscheinlich, da die Streckung des Bereichs an der Art der Verteilung der Werte nichts ändert.
- Wertebereich des Ausdrucks »3 * global::Microsoft.JScript.MathObject.random()«
3 * global::Microsoft.JScript.MathObject.random()
0 0.25 0.5 0.75 1.0 1.25 1.5 1.75 2.0 2.25 2.5 2.75 3.0 3.25 3.5 3.75 4.0
| ' ' ' | ' ' ' | ' ' ' | ' ' ' |############################################################
Solch eine Multiplikation eines Bereichs mit einem positiven Faktor nennt man auch Skalierung. Falls der Faktor größer als »1« ist, spricht man von einer Streckung. Falls der Faktor kleiner als »1« ist, spricht man von einer Stauchung.
Das folgende Diagramm zeigt den Wertebereich des Ausdrucks »global::System.Math.Floor( 3 * global::Microsoft.JScript.MathObject.random() )« mit Hilfe von Nummernzeichen an.
Die drei Werte sind darin weiterhin gleich wahrscheinlich, weil zu jedem Wert des folgenden Diagramms ein Bereich aus dem vorigen Diagramm gehört, dessen Breite eins beträgt. Dadurch ergibt sich der Wert »1« gleich vielen Fällen wie der Wert »2« oder der Wert »3«.
- Wertebereich des Ausdrucks »global::System.Math.Floor( 3 * global::Microsoft.JScript.MathObject.random() )«
global::System.Math.Floor( 3 * global::Microsoft.JScript.MathObject.random() )
0 0.25 0.5 0.75 1.0 1.25 1.5 1.75 2.0 2.25 2.5 2.75 3.0 3.25 3.5 3.75 4.0
| ' ' ' | ' ' ' | ' ' ' | ' ' ' |# # #
Beispiel Schriftzeichen von Kennzahlen
Die Methode »global::System.Char.ConvertFromUtf32« ordnet ihrem numerischen Argumentwert ein Schriftzeichen vom Typ »string« zu.
Program.cspublic static class Program
{ public static void Main()
{ global::System.Console.WriteLine
( global::System.Char.ConvertFromUtf32( 65 )); }}ProtokollA