Teil 4: Variablen

TIGCC-Tutorial für Einsteiger.

Teil 4: Variablen

Beitragvon saubue am 27. Juli 2008 00:24

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:

TIGCC Library hat 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.

Vorsicht: Die obigen Datentypenbezeichner sind zwar in C standardisiert, die tatsächliche Bitweite der Typen jedoch nicht. Kleines Beispiel: ein int hat auf x86-Rechnern normalerweise 32 Bit, auf dem M68000 (dem Prozessor eures Taschenrechners) 16 Bit. Wenn ihr also auch C-Programme für andere Prozessoren schreibt, solltet ihr auf die unterschiedliche Bitweite dieser Typen für das jeweilige (Betriebs-)System achten.

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'):

Code: Alles auswählen
// C Source File
// Created 06.12.04; 19:03:56

#include <tigcclib.h>

// 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.

Code: Alles auswählen
   // 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.

Code: Alles auswählen
   // 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.

Code: Alles auswählen
   // 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 eben 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')

Code: Alles auswählen
// C Source File
// Created 06.12.04; 19:03:56

#include <tigcclib.h>

// 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.

Code: Alles auswählen
   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?

Code: Alles auswählen
      // 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 erniedrigt oder mit ~ Bit für Bit negiert (um einige zu nennen).

Code: Alles auswählen
      // 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 maximakle 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.

Code: Alles auswählen
   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!
"All animals are equal. But some animals are more equal than others." - George Orwell (Animal Farm)

boolsoft - software development for texas instruments 68k calculators
Benutzeravatar
saubue
Administrator
Administrator
 
Beiträge: 1434
Registriert: 11. März 2005 13:55
Wohnort: Freiburg im Breisgau

Zurück zu Grundlagen: TIGCC

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

cron