Vergleiche in C♯ 

In dieser Lektion wird der binäre Infixoperator »<« behandelt, mit dem eine Aussage geschrieben werden kann, die besagt, daß der Wert des ersten Operanden kleiner als der Wert des zweiten Operanden ist.

Program.cs

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

Protokoll

True

Vereinfachte Syntax

Syntaxdiagramm

Ausdruck
    .----------.     .-.    .----------.
--->| Ausdruck |--->· < ·-->| Ausdruck |--->
    '----------'     '-'    '----------'

Mathematische Schreibweise

Die mathematische Schreibweise dieses Operators ist ebenfalls ‹<›.

Aussprache

Der Operator wird „kleiner“, „kleiner als“ oder „ist kleiner als“ gesprochen.

Man kann »2<x« aber auch umgekehrt als „x ist größer als 2.“ aussprechen.

Priorität

Die folgende Tabelle gibt die Assoziativität und Priorität der bisher behandelten Operatoren wieder.

Eigenschaften

       S P A    (S = Stelligkeit ("Aritaet"), P = Position, A = Assoziativitaet)
()     1 Z      Eingeklammerter Ausdruck
+  -   1 P      Unaere vorangestellte Operatoren (Vorzeichen)
*  /   2 I L    "Punktrechnung":  Multiplikation, Division
+  -   2 I L    "Strichrechnung": Addition, Subtraktion
<      2 I L    Vergleich
== !=  2 I L    Gleichheitspruefung und Ungleichheitspruefung
=      2 I R    Zuweisung

Die Priorität dieses Operators ist schwächer als die der Operatoren zur Berechnung eines Wertes aber stärker als die der Gleichheitsprüfungen und der Zuweisungen.

Wir illustrieren die Priorität dieses Operators durch Auflistung einiger Ausdrücke gleicher Bedeutung.

Priorität

Ausdruck               Ausdruck mit gleicher Bedeutung
false == a < 2         false ==( a < 2 )
x = a < 2              x =( a < 2 )
2 + 3 < a * -4         ( 2 + 3 )<( a * -4 )

Typanforderungen (vereinfacht)

Bei den Operanden dieses Operators muß es sich um numerische Typen  handeln. Bei einer Kombination von »int« und »double« wird der int -Wert vor dem Vergleich nach double  gewandelt.

Mögliche Gleichheitsprüfungen (symbolische Schreibweise)

int     < int
int     < double  (als double < double)
double  < int     (als double < double)
double  < double  (als double < double)

Typ des Ausdrucks

Der Typ eines mit diesem Operator gebildeten Ausdrucks zum Vergleich ist immer »bool«.

Semantik (Wert)

Bei der Auswertung dieses Operators werden zunächst beide Operanden ausgewertet.

Der Wert ist »true« genau dann wenn der Wert des linken Operanden kleiner ist als der Wert des rechten Operanden.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine( 1 < 2 );
    global::System.Console.WriteLine( 0.0 < 0.00 );
    global::System.Console.WriteLine( 1.9999999999999999 < 2.0 ); }}

Protokoll

True
False
False

Beispiele

Der Wert eines Aufrufs von »global::Microsoft.JScript.MathObject.random()« darf nicht negativ sein.

Das folgende Programm setzt den Wert der Variablen »zuKlein« auf »true«, falls doch einmal gegen diese Regel verstoßen werden sollte. Wir erwarten aber keinen Verstoß gegen diese Regel und somit die Ausgabe des Wertes »false«.

Program.cs

public static class Program
{ public static void Main()
  { double zufallszahl = global::Microsoft.JScript.MathObject.random();
    bool zuKlein = zufallszahl < 0;
    global::System.Console.WriteLine( zuKlein ); }}

Protokoll

False

Das folgende Programm erledigt die Prüfung mit einer Methode.

Protokoll

false

Program.cs

public static class Program
{
  public static bool zuKlein( double x )
  { return x < 0; }
  public static void Main()
  { double zufallszahl = global::Microsoft.JScript.MathObject.random();
    global::System.Console.WriteLine( zuKlein( zufallszahl )); }}

Protokoll

False

Der Wert eines Aufrufs von »global::Microsoft.JScript.MathObject.random()« darf nicht 1 oder mehr sein.

Das folgende Programm setzt den Wert der Variablen »zuGross« auf »true«, falls doch einmal gegen diese Regel verstoßen werden sollte. Wir erwarten aber keinen Verstoß gegen diese Regel und somit die Ausgabe des Wertes »false«.

Program.cs

public static class Program
{ public static void Main()
  { double zufallszahl = global::Microsoft.JScript.MathObject.random();
    bool zuGross = zufallszahl < 1 == false;
    global::System.Console.WriteLine( zuGross ); }}

Protokoll

False

Das folgende Programm setzt den Wert der final-Variablen »schlecht« auf »true«, falls sich eine Zufallszahl außerhalb des erlaubten Bereich befindet. Wir erwarten also »False«.

Program.cs

public static class Program
{ public static void Main()
  {
    double zufallszahl = global::Microsoft.JScript.MathObject.random();
    bool zuKlein = zufallszahl < 0;
    bool zuGross = zufallszahl < 1 == false;
    bool schlecht = zuKlein != zuGross;
    global::System.Console.WriteLine( schlecht ); }}

Protokoll

False

Man beachte, wie die sprechenden Variablennamen das Verständnis des Programms erleichtern.

Übungsfragen

?   Übungsfrage

Welche Ausgabe erzeugt das folgende Programm?

Program.cs

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

?   Übungsfrage

Welche Ausgabe erzeugt das folgende Programm?

Program.cs

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

?   Übungsfrage

Welche Ausgabe erzeugt das folgende Programm?

Program.cs

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

Unendlich und die Unzahl *

Unendlich gilt als größer als jeder andere double-Wert (außer die Unzahl “not a number ”) und minus Unendlich gilt als kleiner als jeder andere double-Wert (außer die Unzahl “not a number ”).

Vergleich mit der Unzahl “not a number ” ergeben stets »false«.

Program.cs

public static class Program
{ public static void Main()
  { 
    double infinity   = 1.0 / 0.0;
    double notANumber = 0.0 / 0.0;
    double maximum    = 1.7976931348623157E+308;
    global::System.Console.WriteLine( "{0:R}", infinity   ); /* Infinity               */
    global::System.Console.WriteLine( "{0:R}", notANumber ); /* NaN                    */
    global::System.Console.WriteLine( "{0:R}", maximum    ); /* 1.7976931348623157E308 */
    global::System.Console.WriteLine(  maximum    <  infinity     ); /* true                   */
    global::System.Console.WriteLine( -infinity   <  infinity     ); /* true                   */
  
    global::System.Console.WriteLine(  maximum    <  maximum + 1  ); /* false                  */
    global::System.Console.WriteLine(  infinity   <  infinity + 1 ); /* false                  */
    global::System.Console.WriteLine(  notANumber <  infinity     ); /* false                  */
    global::System.Console.WriteLine(  notANumber == infinity     ); /* false                  */
    global::System.Console.WriteLine(  infinity   == notANumber   ); /* false                  */
    global::System.Console.WriteLine(  infinity   <  notANumber   ); /* false                  */
    global::System.Console.WriteLine(  notANumber <  notANumber   ); /* false                  */ }}

Protokoll

Infinity
NaN
1.7976931348623157E+308
True
True
False
False
False
False
False
False
False