Variablen
In jeder Programmiersprache sind Variablen natürlich von entscheidender Bedeutung, da ohne sie Daten sehr schwer oder gar nicht verarbeitet werden können. In C gibt es zwei Grund-Typen von Variablen: int (Integer = ganze Zahl) und char (Charakter = Zeichen). Sie unterscheiden sich im Wesentlichen durch ihren Wertebereich, wobei es vom Typ int noch einige Modifikationen gibt.

Die Wertebereiche können wir der entsprechenden Tabelle aus der TIGCC Library entnehmen:

Quote: TIGCC Library hat folgendes geschrieben:
short int -32768 to 32767 
long int -2147483648 to 2147483647 
signed char -128 to 127 
signed int -32768 to 32767 (signed is default) 
signed short int -32768 to 32767 
signed long int -2147483648 to 2147483647 
unsigned char 0 to 255 
unsigned int 0 to 65535 
unsigned short int 0 to 65535 
unsigned long int 0 to 4294967295


Die Bedeutung dessen wollen wir uns kurz klar machen:
signed: Die Variable kann einen negativen Wert haben
unsigned: Die Variable kann nur einen Positiven Wert haben (und 0 natürlich)
long: Der Wertebereich ist gößer (nur bei int)
short: Der Wertebreich ist kleiner (nur bei int)
Dazu noch ein paar Bemerkungen:
Wir ihr seht, haben die Variablen unterschiedliche Wertebreiche, was bedeutet, das sie unterschiedlich groß sind und somit unterschiedlich viel Speicherplatz brauchen. Eine Variable vom Typ char benötigt 8 Bits (was 2^8=256 Möglichkeiten der Belegung der Bits ergibt), eine Variable vom Typ short int 16 Bits (2^16=65536 Möglichkeiten) und eine Variable vom Typ long int 32 Bits (2^32=424967296 Möglichkeiten). Des weitern laufen int, short int und short sowie long und long int auf das Selbe hinaus. Wir werden hierbei jeweils short und long gebrauchen.

Vielleicht habt ihr euch schon gefragt, wieso ich oben geschrieben habe, das char Zeichen bedeutet, im Auszug jedoch Zahlen als Werte definiert sind. Es ist relativ simpel: Der ANSI-Zeichensatz besteht aus 256 Zeichen (von denen die ersten 33 (0-32) Steuerzeichen sind). Diesen Zeichensatz gibt es (wenn auch leicht abgeändert) auch für euren Taschenrechner. Ihr könnt sie mit dem char()-Befehl auf dem TI abrufen (Argumente von 0-255).

Hierzu ein kleines Beispiel (namens 'var1'):

// C Source File 
// Created 06.12.04; 19:03:56 

#include  

// Haupt-Funktion 
void _main(void) 
{ 
   // Variable für den 'Input' 
   short wert; 
    
   // Löschen des Bildschirms 
   clrscr(); 
    
   // Auf Eingabe warten 
   printf("Bitte eine Taste drücken...\n\n"); 
   wert = ngetchx(); 

   // Ausgabe der Werte 
   printf("Dezimalzahl: %d\n", wert);  // Als Dezimalzahl der Taste 
    
   if (wert < 256) 
      printf("Buchstabe: %c\n", wert);  // Als ANSI-Zeichen 
   else 
      printf("Buchstabe: Error (Zahl ist zu groß)\n"); 
    
   printf("Hexadezimalzahl: 0x%x\n", wert);  // Als Hexadezimalzahl 
    
   // Auf Tastendruck warten 
   ngetchx(); 
}


Hier gibt's jetzt ein bisschen was altes und ein bisschen was neues:

Zuerst einmal: Was macht das Programm? Es liest den Wert eines Tastendrucks (also den 'Wert' einer Taste) und gibt diesen als Dezimalzahl, als ANSI-Zeichen (falls möglich) und als Hexadezimalzahl aus. Solltet ihr mit diesen Zahlensystemen noch nicht vertraut sein, könnt ihr euch auf Wikipedia näher informieren.

Nun zum Code:

Wir deklarieren zuerst die Variable. 

   // Variable für den 'Input' 
   short wert;


Das muss nicht am Anfang geschehen; Variablen kann man eigentlich jederzeit deklarieren, doch der Übbersicht halber werde ich sie in unseren Beispielen immer am Anfang einer Routine deklarieren. Die Variable hat den Typ short, und wie wir oben ennehmen klönnen, somit einen Wertebereich von -32768 bis 32767. Das reicht für unsere Zwecke vollkommen aus; Tastencodes reichen meines Wissens eh nicht über 10000. Möglich wäre natürlich auch unsigned short gewesen, da wir ja nur positive Werte haben.

   // Auf Eingabe warten 
   printf("Bitte eine Taste drücken...\n\n"); 
   wert = ngetchx();


Anschliessend wird unserer Variable 'wert' also der Tastencode der Taste, die wir gedrückt haben, zuigewiesen. Anschliessend wird er ausgegeben.

   // Ausgabe der Werte 
   printf("Dezimalzahl: %d\n", wert);  // Als Dezimalzahl der Taste 
    
   if (wert < 256) 
      printf("Buchstabe: %c\n", wert);  // Als ANSI-Zeichen 
   else 
      printf("Buchstabe: Error (Zahl ist zu groß)\n"); 
    
   printf("Hexadezimalzahl: 0x%x\n", wert);  // Als Hexadezimalzahl


Hier sehen wir eine weitere Funktion von printf(): Es ist möglich, Daten (z.B. Zahlen) direkt in einen String umzuwandeln.Hierzu benötigen wir das Prozent-Zeichen und einen Buchstaben, der das Format der Variablen beschreibt. d steht für signed decimal integer, also eine Ganzzahl, die sowohl positiv als auch negativ sein kann und im Dezimalzahlensystem ist. Logischerweise wird also beim Drücken von z.B. 'a' '97' (der Tastencode) ausgegeben. Ist 'wert' nicht größer als 255, können wir das entsprechende ANSI-Zeichen ausgeben. Für unser Beispiel mit 'a' wäre das natürlich 'a'. Wir wir sehen, benötigen wir hier das Format c, was soviel heisst wie character, also ein Zeichen. Der Compiler versteht darunter ein ANSI-Zeichen, welches ja wiederum durch eine Zahl beschrieben wird. Am Schluss wird die Variable als Hexadezimalzahl dargestellt und deshalb x (lowercase hexadecimal integer) als Format angegeben wird. Üblicherweise wird '0x' vor eine Dezimalzahl geschrieben, um diese zu kennzeichnen. Also haben wir das eben vor das & geschrieben. Der Vorgang ist ähnlich wie oben, 'wert' wird ebeb in einem anderen Format ausgegeben.

Mehr über die einzelnen Ausgabeformate findet ihr in der TIGCC Documentation unter dem Befehl printf.

Ich hoffe ihr habt jetzt einigermassen eine Vorstellung von Variablen und deren Benutzung. Trotzdem gibt's noch ein weiteres Beispiel (nennt es einfach 'var2')

// C Source File 
// Created 06.12.04; 19:03:56 

#include  

// Haupt-Funktion 
void _main(void) 
{ 
   unsigned short loop = 0; // Schleifenvariable 
   char msg[5]; // Ausgabestring 

   ClrScr(); 
    
   // Schleife durchführen, bis der User [ESC] drückt 
   do { 
      // Schleifenvariable um 1 erhöhen 
      loop++; 
       
      // Schleifenvariable anzeigen 
      sprintf(msg, "%u", loop); 
      DrawStr(0, 0, msg, A_REPLACE); 
       
      // Falls der Wert zu groß wird, das Programm beenden 
      if (loop >= 65535) 
         return; 
          
   } while (!_keytest(RR_ESC)); 
    
   while (_rowread(0)) continue; 
}


Zuerst einmal schauen wir uns das fertige Programm wieder an. Es sollte relativ klar sein, was gemacht wir, doch einig Punkte will ich noch genauer erklären.

   char msg[5]; // Ausgabestring


Was ist das? Eine Variable vom Typ char, das ist selbstverständlich, aber wozu das '[5]'? Nun, in C gibt es keinen String-Typ wie in BASIC oder Java. Also sind wir gezwungen, uns einen "zusammenzubauen": char können wir als Zeichen verwenden, und wir haben nun mit diesem '[5]' eine Liste ('Array': Hierzu im nächsten Kapitel mehr) vom Typ char mit 5 Elementen erzeugt. Als haben hier 5 Variablen vom Typ char Platz. Wir können diese List als Zeichenkette benutzten, was im Prinzip ja einen String darstellt. Einleuchtend?

      // Schleifenvariable um 1 erhöhen 
      loop++;


Hier seht ihr nun etwas sehr praktisches: In C gibt es verschiedene Möglichkeiten, eine Variable einfach zu ändern (siehe hierzu 'C Language Operators and Punctuators' in der TIGCC Doc). Mit ++ wird die Variable um 1 erhöht, mit -- um 1 weniger oder mit ~ Bit für Bit negiert (um einige zu nennen).

      // Schleifenvariable anzeigen 
      sprintf(msg, "%u", loop); 
      DrawStr(0, 0, msg, A_REPLACE);


Also weiter im Code: als nächstes ist sprintf() dran. Diese Funktion ist ähnlich wie printf (schon vom Namen her) und wandelt ebenso eine Reihe von Buchstaben (auch hier sind Argumente erlaubt) in einen String um, mit dem unterschied, das er nicht direkt ausgegeben wird, sondern in einem Array vom Typ char gespeichert wird. Mit DrawStr oder einer ähnlichen Funktion können wir ihn dann ausgeben.
Anschliessend bauen wir noch eine Sicherheitsabfrage ein; der macimakle Wert einer Variablen vom Typ short beträgt ja bekanntlich 65535. Diesen Wert wollen wir ja nicht überschreiten, da sonst ein Error auftreten könnte. Also beenden wir in diesem Fall das Programm mit return.

   while (_rowread(0)) continue;


Mit dieser kurzen Zeile stellen wir sicher, das der Tastatur-Speicher komplett leer ist. Auf die Funktionsweise will ich hier jedoch noch nicht eingehen (dazu später).

Das war also Kapitel 4, und nun solltet ihr über Variablen eighentlich bestens informiert sein... . Nächstes mal werden wir dann mit Sprites usw. angangen.
Und immer schön üben!