Advanced  Services

Datentypen und Variable

Unser erstes Programm brachte lediglich eine Ausgabe auf die Konsole. Um mehr zu erreichen, brauchen wir u.a. die Möglichkeit Werte für Berechnungen zu speichern. Am Anfang eines Programms (oder auch später) vereinbart man Speicherplätze, auf die man dann im Laufe des Programms zugreift. Diese werden zur Laufzeit im Hauptspeicher realisiert. Man gibt den Speicherplätzen symbolische Namen, aus denen das Betriebssystem zur Laufzeit physikalische Adressen macht. Diese Namen heißen Bezeichner. Nicht alle Namen sind erlaubt, dazu später mehr. Gültige Bezeichner sind etwa  zahl  oder  wort  oder   woRT . Wie immer wird Groß- und Kleinschreibung unterschieden (casesensitiv). Es bedeuten also  wort  und  woRT  zwei verschiedene Speicherplätze. Einen Speicherplatz nennen wir ab jetzt eine Variable. Variablen haben bestimmte Werte, die sich während des Programmablaufs ändern können. Namen für Variable reichen nicht aus, man muß auch die Struktur des Speicherplatzes angeben, oder anders gesagt, man muß angeben, was für einen Typ die Variable haben soll. In C# unterscheidet man zwischen Werttypen (valuetypes) und Referenztypen bzw. Verweistypen. Im Gegensatz zu Java und C++ sind die Werttypen in die Hierarchie der Verweistypen mit eingebunden. Aus diesem Grund gibt es eine Vielzahl von Werttypen und wir werden hier nur die wichtigsten vorstellen. Zudem gibt es mit dem Schlüsselwort struct ähnlich wie in C++ die Möglichkeit eigene Werttypen zu erstellen. Die vordefinierten Werttypen werden u.a. für ganze Zahlen, Kommazahlen, Zeichen und Wahrheitswerte verwendet. Damit haben wir (zunächst) vier verschiedene Sorten von Werttypen.

Die Namen int, double, char und bool sind reservierte Namen und dürfen nur in diesem Zusammenhang benutzt werden. Eine ausführlichere Liste der Werttypen findet sich unter diesem Link.

Eine Vereinbarung hat die Form

datentypname  bezeichner1,  bezeichner2,  bezeichner3 ;

Es ist ein guter Brauch, Variablen am Anfang eines Blockes zu vereinbaren, also nach einer sich öffnenden geschweiften Klammer. Objektorientierte Sprachen erlauben jedoch auch noch spätere Vereinbarungen. Im folgenden finden sie Vereinbarungen am Anfang von main:

using System;

public static void Main()
{
   int a, b, c ;
   // Vereinbarung von drei Variablen vom Typ int (ohne Wertzuweisung)
   double x=2.7, y=7.2, z=27 ;
   // Vereinbarung von drei Variablen vom Typ double (mit Wertzuweisung)
}

Die Liste muß mit einem Semicolon abgeschlossen werden. Statt Vereinbarung sagt man auch Deklaration oder Definition. Eine Wertzuweisung bei der Deklaration nennt man Initialisierung. Hat man Variable nicht initialisiert, muß man das spätestens vor der ersten Verwendung tun.

Eine Anweisung oder ein Statement "macht" etwas mit den vereinbarten Variablen. Dazu erweitern wir das obige Beispiel.

public static void Main()
{
   int a, b, c ;
   double x=2.7, y=7.2, z=27 ;

   a = 17 ; //Wertzuweisung, a erhält den Wert 17
   b = a ;  // Wertzuweisung, b erhält den Wert von a
   c = 3*a - a/2 ; // Wertzuweisung, c erhält den Wert einer Berechnung
   Console.WriteLine("c = " + c);  // Ausgabe von c auf die Konsole
   Console.WriteLine("Das wars vorerst");
}

Es gibt eigentlich nur drei Arten von Statements, zwei davon sehen wir oben, Zuweisungen und Unterprogrammaufrufe, in objektorientierter Sprache Methodenaufrufe genannt. Die dritte Variante ist ein Statement, das mit Hilfe einer Kontrollstruktur gebildet wird, also etwa mit einer Verzweigung (if/else) oder einer Schleife (for). Diese Art von Statement zerfällt meist wieder in mehrere Teilstatements.

Welche Namen soll man den Variablen geben. a, b, c sind zwar kurz, aber nichtssagend. Besser sind sprechende Namen. Werden sie geschickt gewählt, so kann man sich erklärende Kommentare sparen. Einen Kommentar schreibt man in der Regel nur an einer einzigen Stelle, die Variable aber unter Umständen ziemlich oft. Und dabei erklärt sie sich ein jedesmal aufs neue, und das ist ein großer Vorteil. Hier z.B. die Bezeichner von einigen Variablen, die selbsterklärend sind.

boolean  leftTextChanged ,  rightTextChanged ;
double  loesung1 ,   loesung2 ;
int  index ;

Regeln für Bezeichner

Bezeichner bestehen aus Buchstaben, Ziffern, dem Unterstrich (underscore) und Währungssymbole. Den Buchstaben liegt dabei der Unicode und nicht der ASCII-Code zugrunde. Dadurch sind eine Vielzahl von besonderen Buchstaben erlaubt wie deutsche Umlaute oder Vokale mit Akzenten usw. Der besseren Lesbarkeit wegen sollte man sich aber auf die Menge der lateinischen Buchstaben beschränken. Bezeichner dürfen nicht mit einer Ziffer beginnen. Ein paar Beispiele:


zahl,  zahl2,  zahl_2,  not_ok ;    // zulässig und üblich
$dollar,  _zahl2 ;    // zulässig, aber selten
ångström,  grüße ;    // zulässig, aber nicht üblich
1index,  not-ok,  dir/bin ;    // falsch


Konventionen für Bezeichner

Bezeichner für Variablen beginnen mit einem kleinen Buchstaben, Bezeichner für Methoden beginnen mit einem großen Buchstaben (im Unterschied zu etwa Java), Bezeichner für Klassen beginnen ebenfalls mit einem großen Buchstaben. Bei zusammengesetzen Namen beginnt jeder Teilname mit einem großen Buchstaben (englisch: camelcase). Besonders bei Klassennamen und Methoden wird diese Konvention strikt eingehalten. Einige Beispiele aus der Standardklassenbibliothek: Drei Klassennamen

Drei Namen von Methoden

Nicht gerade kurz, diese Namen, aber recht einprägsam. Es wird empfohlen, sich an diese Konventionen zu halten. Alle Profis tun dies. Diese Spielregeln erhöhen die Lesbarkeit von Quellcode drastisch. Es könnte ja mal auch Vorkommen, daß man ein fremdes Programm liest (lesen muß) oder das eigene, ein paar Monate später...

Datentypen und Variable