Wilkommen beim zweiten Teil des C-Kurses.

Wie am Ende des ersten Teils versprochen wurde, befassen wir uns heute mit der Datenein- und Datenausgabe. Und wie immer: Erstmal etwas Theorie :-) Kein Panik, ist nicht schlimmer als im ersten Teil.
 
 
DIE VARIABLEN

Variablen bestehen aus einem Variablennamen und einem Variablentyp. Das kann man vergleichen mit einem Behälter, wo drauf steht, was drin ist. Durch den Variablennamen geben wir dem Behälter einen eindeutigen Namen, denn wir wollen ja den Behälter später wieder finden. Wie immer ein kleines Beispiel:
 

/* Variablen sind eine feine Sache */ 
#include <stdio.h>

 
void main (  void ) 
{
int anzahl;
anzahl=100; 
printf ("\nAnzahl = %d \n",anzahl);
}

Ich sehe schon die Fragezeichen aufleuchten: "Was bitte soll das %d hier ?" Wie immer: Mysterien sind da, um gelöst zu werden. Doch der Reihe nach...

Am Anfang wird die Variable Anzahl erzeugt. Dies geschieht, in dem nach dem Variablentyp die zu erzeugende Variable, hier Anzahl, steht. Danach wird der Variablen der Wert 100 zugewiesen. Wir haben nun einen Behälter (Variable) von einer bestimmten Größe (int). Den Behälter füllen wir nun mit einem Wert, in dem Fall 100. Danach wird der Wert ausgegeben.
 
 
 
 
Grundlegende Variablentypen

Wir machen kurz einen Werbeblock für die Behälterindustrie: C kennt folgende Grundtypen einer Variable, die dem folgenden Wertebereich entsprechen:

Double-Größen unterscheiden sich von den Float-Größen nur in ihrem Wertebereich. Dadurch, das die double-Variablen doppelt soviel Speicherplatz wie die float-Variablen belegen, können mit ihnen natürlich auch mehr Zahlen dargestellt werden.

Dem Variablentypen 'int' kann nun noch eins der Schlüsselwörter 'signed' oder 'unsigned' vorangehen. Steht 'signed' davor, kann das Programm Vorzeichen unterscheiden; steht 'unsigned' davor, dürfen nur positive Werte benutzt werden. Wo da der Sinn liegt ? Die Variablen belegen je nach Type eine bestimmte Menge Speicher, den sie benötigen um eine Variable abzuspeichern. Damit alles gleichmäßig verteilt ist, ist der Anteil der negativen Zahlen genauso groß wie der, der positiven. Steht ein 'signed' davor, so benutzt das Programm die positiven und negativen Wertebereiche. Steht ein 'unsigned' davor, wird nur der positive Teil betrachtet. Moment, was passiert mit dem restlichen negativen Anteil ? Genau, da er uns auch etwas bringen soll, benutzen wir ihn einfach mit und hängen ihn an den positiven Wertebereich hinten an. Damit könenn wir also doppelt soviele positive Zahlen darstellen, wie mit dem 'signed' Variablentyp. Das kann nützlich sein, wenn man eh keine negativen Zahlen benötigt. Bei den int-Variblentypen kann zusätzlich noch 'long' oder short 'short' vergesetzt werden. Wie unten zu sehen ist, gibt es zwei int-Wertebereiche; einmal für 16-Bit Maschinen und 32-Bit Maschinen. Sowas ist echt ärgerlich und kann einen ganz schön ins Fettnäpfchen treten lassen. Wenn 'short' davor steht, werden die 16-Bit Wertebreiche und bei 'long' die 32-Bit Wertebereiche verwendet.

Grundsätzlich sind alle 'int' - Variablen 'signed' , wenn nichts explizit angegeben ist!
 
 
 
 
Hier nun die Wertebereiche der Variablentypen:

 

int
- 32 768 ... 32 767 (16 Bit Maschinen) 

- 2 147 483 648 ... 2 147 483 647 (32 Bit Maschinen)
unsigned int
0 ... 65 535 (16 Bit Maschinen) 

0 ... 4 294 967 295 (32 Bit Maschinen)
short int
- 32 768 ... 32 767
long int
- 2 147 483 648 ... 2 147 483 647
unsigned short int
0 ... 65 535
unsigned long int
0... 4 294 967 295

Wie das bei 'signed short int' und 'signed long int' aussehen könnte ist Hausaufgabe :)
char
alle ASCII-Zeichen ,
das sind alle Zeichen, die man auf dem Bildschirm darstellen kann
unsigned char
alle ASCII-Zeichen

Wie das zustande kommt, am Ende der Tabelle - löst sich in wohlgefallen auf! Versprochen!
float
float -10 ^38 ... 10 ^38
double
-10 ^308 ... 10 ^308

Um kurz das 'unsigned char' - Problem zu lösen einen kleinen Ausflug in die Rechnerwelt von Vorgestern. Früher gab es zwei Arten ASCII-Zeichen, das sind die darstellbaren Zeichen, zu kodieren. Da Rechner intern nur mit Zahlen arbeiten, mußten die Zeichen in irgendeiner Form als Zahlen dargestellt werden. Die einen sagten: Wir nehmen den Wertebereich von -128 ... 127 . Die anderen sagten sagten sich: Was soll´s, ist eh nur eine Aufzählung, laßt uns bei 0 beginnen , wie es sich gehört :-) Dieser Wertebereich ging also von 0 ... 255. Um diesem Problem der Unterschiedlichen ASCII-Werte zu entgehen, wurde der 'unsigned char' Typ eingeführt, welcher nur Werte von 0 ... 255 kennt. Prinzipiell wird heute nur noch mit 'unsigned char' gearbeitet, das heißt dieses Problem werden wir einfach unter den Tisch kehren.

Ist Ihnen noch was aufgefallen ? Der positive Wertebereich hat scheinbar eine Zahl weniger :-) Nein, nicht wirklich, die 0 wurde einfach den positiven Zahlen zugeordnet. So, jetzt haben wir genausoviele positive wie negative Zahlen.

Zurück zu unserem Programm, schon abgetippt und gestartet ? Auf dem Bildschirm müßte jetzt stehen:
 

Anzahl = 100

Toll! Aber was sollte das %d dort ? Wie im letzten Teil schon erwähnt ist das % ein Sonderzeichen, genau wie der \ . Das % sagt dem Programm, das dort der Wert einer Variable stehen soll. In dem Fall %d wird eine integer-Variable angezeigt.Diese muß innerhalb des printf-Befehls innerhalb der Klammer stehen.

Aufzählungen von Variablen werden mittels eines Kommas getrennt!
 
 
 
 
Variablenzuweisungen innerhalb scanf

 

%d
int oder short int als Dezimalzahl darstellen
%ld
long int als Zahl darstellen
%c
char als Zeichen  ausgeben
%x
wie %d als Hexadezimal mit kleinem a...f 
%X
wie %d als Hexadezimal mit großem A...F 
%o
wie %d als Oktalzeichen
%u
wie %d , aber nur Werte ohne Vorzeichen
%f
Floatzahlen in Fließkommaschreibweise , z.B. 3.43234
%e
Floatzahlen in Exponentialschreibweise , z.B. 23e+432 
%E
wie %e nur mit großen E , z.B. 23E+432
%g
Exponential- oder Fließkommaschreibweise ,
in Abhängigkeit vom Wert
%s
char* , bzw. char[ ]
%le
double darstellen 
%%
Gibt ein % aus.  Braucht man ja ab und zu.

In unserem Programm steht also, das an der Stelle, wo das %d steht, die Variable vom Typ Ganzzahl (int) dort eingesetzt werden soll.

Probieren sie ruhig das folgende Beispiel aus und versuchen sie zu verstehen, was es macht:
 

/* Wie kann ich ein Zeichen darstellen */ 
#include <stdio.h>

 
void main ( void ) 
{
    char zeichen;
    zeichen='d';

     
    printf ("\nDas Zeichen %c ist im ASCII-Code ein %d \n",zeichen,zeichen);
}

Ein anderes Beispiel:
 

/* Floats sind auch nur Zahlen */ 
#include <stdio.h>

 
void main ( void ) 
{
    float zahl=5.01;

     
    printf ("\nEine Floatzahl einmal so %f und einmal so %e \n",zahl,zahl);
}

Bei unserem letzten Beispiel haben wir noch etwas neues gemacht: Der Variablen wird gleich ein Wert bei deren Erzeugung zugewiesen!

Wir können also statt:
 

float zahl; 

zahl=102.033;

auch schreiben:
 

float zahl=102.033;

 
 
 
 
 
Dateneingabe

Bei der Dateneingabe bitte obere % - Formatanweisungen im Hinterkopf behalten. Wie gewohnt ein Beispiel , an dem wir uns dann entlangseilen werden.
 

/* Variablen zu lesen macht auch Spasz */ 
#include <stdio.h>

 
void main ( void ) 
{
    int anzahl;

     
    printf ("\nBitte eine Integer-Zahl eingeben : "); 
    scanf (" %d ",&anzahl);
    printf ("\n\nSie gaben %d ein\n",anzahl); 
}

Versuchen sie zu erkennen, was das Programm macht. Das ganze Programm dürfte für sie ein Kinderspiel sein, bis auf: scanf (...). Dieser Befehl dient der Dateneingabe. Als ausgabe steht nur, welche Variablentypen eingelesen werden und an welche Variablen die Daten übergeben werden.

In unserem Beispiel: mittels des %d erkennt der scanf-Befehl, das eine Integer-Variable eingelesen werden soll. Standartmäßig wird dieser Wert von der Tastatur eingelesen. Tippen wir einfach mal 42 ein und schließen das mit Druck auf die Return-Taste ab. Das Programm hat nun einen Wert ( 42 ) von uns, den es irgendwo ablegen muß. Mit '&anzahl' sagen wir dem Programm, das der Wert in den Speicherplatz der Variable anzahl geschrieben werden soll. Danach besitzt die Variable den von uns eingegebenen Wert, den wir , freundlich wie wir numal sind, auch auf dem Bildschirm wieder ausgeben.
 
 
 
 
Hausaufgaben

Folgendes Beispielprogramm:
 

/* HAUSAUFGABE fuer den AOL C-Kurs */ 
#include <stdio.h>

 
void main (  void )
{
    float zahl1, zahl2, zahl3;

     
    printf ("\n\nBitte geben sie zwei Flieszkommazahlen ein [z.B. 2.34 , 5.23] ");
    scanf ("%f ,%f",&zahl1,&zahl2);
    zahl3 = zahl1 + zahl2;

     
    printf ("\n\n %f + %f = %f \n\n",zahl1, zahl2, zahl3);
}

Kleiner Hinweis: Die zwei einzugebenden Zahlen sind durch ein Komma zu trennen.
 
 

AUFGABE

1) Was macht das Programm ? Versuchen sie Zeile für Zeile zu verstehen.

2) Ändern sie das Programm so ab, das keine Floatgrößen, sondern Ganzzahlige (int) Werte eingelesen und ausgegeben werden.

3) Probieren sie selbiges einmal mit char-Variablen und überlegen sie, warum das Ergebnis so aussieht und was es mit der Addition von Buchstaben auf sich hat.
 
 
 
 
 
...das Obligatorische

Autor: Sebastian Cyris \ PCD Bascht

Dieser C-Kurs dient nur zu Lehrzwecken! Eine Vervielfältigung ist ohne vorherige Absprache mit dem Autor verboten! Die verwendete Software unterliegt der GPL und unterliegt der Software beiliegenden Bestimmungen zu deren Nutzung! Jede weitere Lizenzbestimmung die der benutzten Software beiliegt, ist zu beachten!