Lektion 2 - Variable und Datentypen

  • Hey Zusammen und Willkommen in der 2. Lektion zu C# 8)

    :s_rechts: Diese Lektion setzt die 1. Lektion zu C# voraus.


    Was sind Variablen?

    Im Grunde können Variablen als Behälter oder Schubladen für entsprechende Inhalte gesehen werden.

    Dabei unterschiedet man zwischen verschiedene Datentypen, also z.B. können manche Variablen Zahlen beinhalten für mathematische Operationen, andere Zeichen (Buchstaben) zur Textausgabe.

    Dieses Grundgerüst findet sich in jeder Programmiersprache - ebenso wie Schleifen, Kontrollstrukturen, ...


    Variablen müssen deklariert werden. Also ihr Datentyp sowie ihre Bezeichnung muss festgelegt werden.

    Es kann ebenso eine Wertzuweisung erfolgen, muss an dieser Stelle jedoch nicht.

    Variablen, die miteinander verknüpft werden, müssen in ihrem Typ verträglich zueinander sein. (Später mehr dazu.)


    Bsp einer Variable:

    double zelle1, zelle2;

    <Datentyp> <Liste oder einzelner Name der Variable>


    Der Name einer Variable ist frei wählbar, solange kein Schlüsselwort (siehe Lektion 1).


    Deklaration von lokalen Variablen

    • Jede lokale Variable muss vor ihrer Verwendung deklariert werden.
      Bsp.: double a, b, c;
    • Bei der Deklaration kann eine Variable mit einem Anfangswert des gleichen Typs initialisiert werden.
      Bsp.: double a = 1.51, b, c;
    • Der Geltungsbereich von lokalen Variablen ist der Block, in dem sie deklariert sind. Im selben Geltungsbereich kann keine andere Variable gleichen Namens vereinbart werden.

    Definition lokaler Konstanten

    • Lokale Variable kann auch als konstant vereinbart werden. Dann ist die Variable nachträglich nicht mehr veränderbar.
    • Eine lokale Konstante muss bei der Vereinbarung initialisiert werden.
      Bsp.: const double pi = 3.1415927;

    Eine Übersicht der in C# vertretenen Datentypen ist hier einzusehen.

    Wir beschäftigen uns am Anfang jedoch erstmal nur mit den folgenden Datentypen:

    bool, char, int, long, uint, ulong, float, double, decimal, string


    Die erwähnten Datentypen haben unterschiedliche Wertebereiche und zählen zu den sog. "einfachen Typen".


    Schlüsselwort Wertebereich
    int -2 147 483 648 … 2 147 483 647
    long -263 … 263-1
    uint 0… 4 294 967 295
    ulong 0 … 264-1
    float +-1.4E-45…+-3.4E38 (32 Bit)
    double +-5E-324…+-1.7E308 (64 Bit)
    decimal +-1E-28…+-7.9E28 (128 Bit)
    bool true, false (wahr, falsch)
    char Unicode-Zeichen
    string Unicode-Zeichen / mögliche Verkettung von char's


    Die einzelnen Wertbereiche sollten hier nicht auswendig gelernt werden, auch wenn ein gewisses Verständnis generell nicht schadet.


    Kurze Zusammenfassung:

    Ganze Zahl

    • Dezimal
    • Hexadezimal: muss mit 0x oder 0X beginnen
    • Suffix u oder U: Konstante wird im Datentyp uint oder ulong gespeichert
    • Suffix L: Konstante wird im Datentyp long gespeichert
    • Typ der Zahl ist der kleinste Typ aus int, uint, long oder ulong, zu dem der Zahlenwert passt.

    Gleitpunktzahl

    • Gebrochener Anteil wird durch Punkt (.) abgetrennt
    • Typ ist double
    • Suffix f oder F: Konstante wird im Datentyp float gespeichert
    • Suffix m oder M: Konstante wird im Datentyp decimal gespeichert

    Beispiele

    12345 => int, dezimal

    1.2345 => double (kein float !)

    1.2345f => float

    0x1A , 0X1A => int, hexadezimal (Wert: 26)

    7926U => uint

    7926L => long

    'B' => char, Zeichenkonstante

    "Maru" => Zeichenkettenkonstante (string)


    Wichtig: uint oder ulong werden nur als Datentypen für positive Zahlen verwendet.

    Es sind hiermit keine negativen Zahlen darstellbar.


    Die für uns wichtigsten Datentypen:

    int, double, string, bool, char


    Zeichen

    • Zeichenkonstanten werden in ‘ ‘ (Hochkomma) eingeschlossen.
      Es dürfen nahezu beliebige Zeichen vorkommen, außer Hochkomma, Zeilenende oder \
      Bsp.: ‘b‘

    Sonderzeichen

    • Escape-Sequenzen zur Darstellung von Sonderzeichen
      Bsp.:
      \n => Neue Zeile
      \t => horizontaler Tabulator
      \‘ => Hochkomma
      \“ => “
      \\ => \

    Zeichenketten (Strings)

    • Zeichenkettenkonstanten werden in “ “ eingeschlossen
      Es dürfen beliebige Zeichen vorkommen, außer Hochkomma, Zeilenende oder \
      Bsp.: “Hallo Welt“
    • Steht vor einer Zeichenkette das Zeichen @, dürfen darin Zeilenumbrüche vorkommen,
      \ wird nicht als Escape-Zeichen interpretiert und “ muss verdoppelt werden.


    Boolescher Datentyp

    • Für die beiden möglichen Werte eines booleschen Ausdrucks sind die Schlüsselworte true („wahr“) und false („falsch“) definiert.
    • Datentyp: bool
    • Benutzung z.B. Schalter (switches, wie beim Maker)
      Bsp.:
    Csharp
    1. bool schalter1 = true;
    2. if (schalter1)
    3. {
    4. // Code der ausgeführt wird, wenn 'schalter1' gleich true ist.
    5. }


    Zuweisung von Werten:

    <linke Seite> = <rechte Seite>

    veränderlicher Wert = wertliefernder Ausdruck


    = als Zuweisungsoperator, ";" als Anweisungsende.

    Bsp.:

    Csharp
    1. int x,y,a,b;
    2. x = 2*y +3; // Anweisung: x wird zu 2*y+3
    3. a = b = 4; // Mehrfachzuweisung: a und b beinhalten nun beide den Wert 4



    Wert-Verträglichkeit / Konvertierbarkeit der Werte


    Frage: Wie lautet bei Ausgabe an die Konsole der Wert von "ergebnis" und "ergebnis2"?



    Eine kleine, aber wichtige Randbemerkung, die auch für zukünftige Lektionen gelten wird!

    => Ihr könnt den Code kopieren. Solltet ihr einen Fehler bekommen, löscht ggf leere Zeilen und setzt diese neu.

    Aufgrund des Lerneffektes wäre es jedoch ohnehin besser, wenn es abgetippt werden würde. So stellt ihr auch sicher, dass keine Symbole falsch in die IDE kopiert werden und euer Programm ohne Fehlermeldung laufen kann.


    Typenumwandlung

    wie im obigen Bsp. gesehen, kennen wir nun die implizite Typenkonvertierung.

    Als grobe Faustregel lässt sich hier sagen: Kleine Datentypen wie lassen sich in größere überführen, große jedoch nicht in kleine zurück.

    Bsp.: byte =>short => int => long => float => double

    Aber double geht nicht in byte oder short, bzw. int, etc.



    Eine weitere Methode zur korrekten Typenumwandlung ist die:


    Explizite Typenumwandlung

    Explizite Typumwandlungen erfolgen:

    • Durch die Verwendung eines Typumwandlungsausdrucks in einer Zuweisung:
      (<neuer Datentyp>) <Ausdruck>;
      Bsp.: int int_var;
      double_var = (double) int_var;
    • Mit der Convert-Klasse:
      Bsp.: string s = Console.Readline();
      double k1 = Convert.ToDouble(s);

    Bei ersteren wird eine int Variable in eine double Variable gewandelt mittels der expliziten Konvertierung "(double)".

    Bei der Convert-Klasse wird sich einer Klasse mit Funktion bedient, die C# zur Verfügung stellt.

    Beides würde zum selben Resultat führen und den int (Integer) als double abspeichern.



    Hinweis zu weiteren Lektionen:

    Bisher haben wir nur Basics und Grundgerüste kennengelernt.

    In den weiteren Lektionen werden teils auch Übungsaufgaben einfließen um das Verständnis zu festigen.

    Es wird angeraten diese möglichst mit der Entwicklungsumgebung nach Wahl durchzuführen und sich daran zu probieren.


    In Lektion 3 behandeln wir die Ein- und Ausgabe auf der Konsole.

    :s_info: Ehemalig in dieser Community als Toothless bekannt, habe ich nun meinen Künstlernamen angenommen: Cryptogene

    So manch einer kennt ja ohnehin schon meine 3D Szenen.


    ninja_pointright Ihr wollt euch für das Forum bedanken und dieses zu 100% unterstützen? Ihr könnt uns finanziell durch eine Schenkung unterstützen. Danke für euren Support!