Tutorial 1_5

Ergänzungen zu Konstanten und Variablen

______________________________________________________________________
// 1_5 Ergänzungen zu Konstanten und Variablen
#include <stdio.h>
#define zahl 10
int nummer = 5;
char wert = nummer;
void main(void)
{
    printf("%d, %d, %d\n", zahl, nummer, wert);
    nummer = 300, wert = nummer;
    printf("%d, %d\n", nummer, wert);
    {
        float nummer = 4.23f;
        printf("%f\n", nummer);
    }
    printf("%d\n", nummer);
    short GehaltSchmidt = 30000;
    typedef unsigned short GEHALT;
    GEHALT GehaltKunze = 30000;
    printf("%d, %d\n", GehaltSchmidt, GehaltKunze);
    GehaltSchmidt+=5000, GehaltKunze+=5000;
    printf("%d, %d\n", GehaltSchmidt, GehaltKunze);
}
______________________________________________________________________
Direkt nach #include steht diesmal schon eine zweite Präprozessoranweisung: #define, diese definiert eine Konstante (in diesem Fall zahl) mit einem Wert (in diesem Fall 10) und ist also nur eine zweite Möglichkeit, einen konstanten Wert zu Speichern und eine alternative zu const. Interesant ist, dass #define keine Angabe des Typs braucht, von dem dem der übergebene Wert sein soll. Der Wert wird automatisch in einer Konnstante von dem Typ gespeichert, der am geeignetsten scheint. Das spart Scgreibarbeit und gibt einem sehr flexible Möglichkeiten, kann aber manchmal nicht zum gewünschten Ergebnis führen. Anschliessend werden noch zwei globale Variablen deklariert, eine vom typ int, eine vom Typ char. Der ersten wird 5 zugewiesen und der zweiten anschließend der Wert der ersten, also auch 5. In der 1,. Zeile der main()-Funktion werden dann die Werte der Konstanten und der beiden Variablen auf dem Bildschirm angezeigt. Anschliessend wird der int-Variablen der Wert 300 zugewiesen und der char-Variablen erneut der Wert der int-Variablen. In der Zeile darauf werden wieder beide angezeigt. Wenn sie das Programm testen, werden sie feststellen, dass mit dem char-Wert was nicht stimmt: statt der erwarteten 300 wird 44 angezeigt. Das kommt daher, dass eine char-Variable/Konstante nur Zahlen von -128 bis 127 speichern kann. Wird dieser Wertebereich überschritten, so wird wider von vorne mit dem Zählen begonnen. 128 wird also als -128 gespeichert, 192 als -64, 256 als 0 und 300 als 44. Diese Begrenzung schränkt die Nutzung von char natürlich ein, aber sie sorgt auch dafür, dass char-Variablen sehr wenig Speicher einnehmen. Nach der zweiten Anzeige der int- und der char-Variablen öffnet sich eine geschweifte Klammer, die nach zwei Anweisungen wieder geschlossen wird. Anweisung 1 definiert eine float-Variable mit 4.23. In Anweisung 2 wird der Wert der float-Variablen angezeigt. Das interessante daran ist nun, dass die float-Variable den gleichen Namen bekommt wie die int-Variable, ohne das der Compiler beim erstellen des Programmes meckert. Ausserdem wird die Variable dieses Namens direkt nach dem Schliessen der geschweiften Klammer wieder angezeigt und plötzlich wird wieder der Wert der int-Variablen angezeigt. Das liegt daran, dass der Compiler streng zwischen den Variablen unterscheidet, die in verschiedenen Ebenen deklariert wurden. Sobald man in einer lokalen Ebene wie z.B. der main()-Funktion eine Variable mit dem gleichen Namen deklariert, wie ihn schon eine globale Variable trägt, so benutzt wird unter diesem Namen bis zum Ende der lokalen Ebene, in unserem Beispiel also bis zum Ende der main()-Funktion die lokale Variable angesprochen, anschließend wieder die globale. Wird nun in einer lokalen Ebene noch eine lokale Ebene geöffnet und hierrin eine Variable mit dem gleichen Namen wie eine aus einer höheren Ebene deklariert, so gilt, diese auch wieder bis zum Ende der Ebene und nur sie kann in dieser Zeit unter diesem Namen angesprochen werden. Also: 1. Eine lokale Variable lebt immer nur vom Anfang bis zum Ende der Ebene, in der sie deklariert wurde. 2. Leben mehrere gleichnamige Variablen gleichzeitig, so kann man über den Variablennamen immer nur eine Variable gleichzeitig ansprechen. Nach dem Ende der lokalen Ebene und dem folgenden printf()-Befehl wird die short-Variable GehaltSchmidt mit dem Wert 30000 definiert. In der nächsten Zeile wird ein neuer Typ mit dem Namen GEHALT als unsigned short definiert. In der darauffolgenden Zeile wird eine Variable vom selbstdefinierten Typ GEHALT mit 30000 initialisiert. Anschliessend werden die Werte der short-Variablen und der GEHALT-Variablen jeweils mit printf() angezeigt, um in den darauffolgenden Zeilen je um 5000 erhöht und dann erneut angezeigt zu werden. Es zeigt sich beim Ausführen des Programmes, das wieder einmal ein völlig unerwartetes Ergebnis angezeigt wird, und zwar bei der short-Variable nach der Erhöhung um 5000. Das liegt daran, dass eine short-Variable zwar nicht eine so begrenzte Menge verschiedener Werte haben kann, wie eine char-Variable, aber doch im Vergleich zu einer int-Variable sehr begrenzt ist. Genau gesagt kann sie nur Werte zwischen -32768 und 32767 annehmen. Bei über- oder unterschreiten wird wieder am anderen Ende des gültigen Bereichs weitergezählt wie bei char. Wenn man aber auf negative Werte verzichten kann, dann kann man durch das Schlüsselwort unsigned ohne, dass die Variable mehr Speicher frisst, auf einen doppelt so hohen Bereich von positiven Zahlen zugreifen. Eine unssigned short-Variable kann also Werte zwischen 0 und 65535 annehmen. Genau das wird bei der GEHALT-Variablen genutzt, denn eigentlich ist sie ja eine unsigned short-Variable, da GEHALT mit typedef als unsigned short definiert wurde.
Zurück