4 Datentypen unter C (Teil I)

4.1 Zahlen, Zahlensysteme

Grundlagen der Zahlensysteme

• Ziffer: Element einer Menge von Symbolen zur Darstellung von Zahlen
• Zahl: Anordnung von Ziffern, die in einem vereinbarten Zahlensystem einen bestimmten Wert darstellen.

• Zeichenvorrat, der die Menge der zulässigen Ziffern darstellt (z. B. Dezimalsystem: 0,1,2,3,4,5,6,7,8,9)
• Bildungsgesetz, das die Anordnung für die Ziffern und die Ermittlung eines Zahlenwertes festlegt.
  Der allgemeine Umgang mit dem Dezimalsystem und dessen Bildungsgesetz läßt uns vergessen, daß verschiedenen Bildungsgesetze existieren können, z. B.:
  • Ziffernwertsystem, bei denen der Zahlenwert alleine durch die Ziffer bestimmt wird (z. B. römische Zahlen)
  • Stellenwertsystem, bei dem der Zahlenwert, den die Ziffer repräsentiert, durch die Position der Ziffer innerhalb der Zahl (= Stelle) bestimmt wird.

Stellenwertsysteme

Für den Wert einer Zahl Z = a_n a_n-1 ... a₀ a_-1 ... a_-m in einem Stellenwertsystem zur Basis B gilt:

wobei für die Ziffern a gilt: 0 <= a < B. Als Basis B bezeichnet man die kleinste, nicht mehr durch eine Ziffer darstellbare Zahl.

Am geläufigsten ist uns das Dezimalsystem mit der Basis 10 (die Festlegung ist rein willkürlich und auf die Zahl der Finger beider menschlicher Hände zurückzuführen).

Die verkürzte Schreibweise durch Aneinanderreihung von Ziffern ist eine abkürzende Schreibweise der Summenformel. Damit kann jede positive und negative reelle Zahl dargestellt werden, indem jede Stelle der Ziffernfolge mit einer Zehnerpotenz gewichtet wird.

Ganze Zahlen:

allgemein:

a_n a_n-1 ... a₁ a₀ = a_n * 10ⁿ + a_n-1 * 10^n-1 + ... + a₁ * 10¹ + a₀ * 10⁰

Echter Dezimalbruch:

allgemein: 0, a_-1 a_-2 ... a_-m = a_-1 * 10^-1 + a_-2 * 10^-1 + ... + a_-m * 10^-m

Dezimalzahl:

Radixschreibweise: Z = a_n ... a₀ a_-1 ... a_-m
Potenzschreibweise: Z = a_n * 10ⁿ + ... + a₁ * 10¹ + a₀ * 10⁰ + ... + a_-m * 10^-m

Dualzahlen

Oktalzahlen

Bei der Eingabe von Oktalzahlen müssen diese - zur Unterscheidung von Dezimalzahlen - gekennzeichnet werden. Dies geschieht durch Hinzustellen der Basis, z. B.: 12517₈. Häufig (besonders bei Programmiersprachen) auch durch Voranstellen von @ oder Anfügen von O,Q,C z.B.: @154 154O 154Q 154C und bei C durch eine führende Null; es gilt also 37 = 37 dezimal, 037 = 37 oktal = 31 dezimal.

Sedezimalzahlen (Hexadezimalzahlen)

Übliche Darstellung der eigentlich binären Information in einem Rechner (Kurzschreibweise binärer Info). Kennzeichnung bei der Programmierung durch Voranstellen von $, Anfügen von H z.B.: $FFC2 FFC2H und bei C durch Voranstellen von "0x" bzw. "0X", z. B. 0xFFC2.

Umrechnung zwischen Stellenwertsystemen

Umwandlung Dezimalsystem --> anderes Stellenwertsystem

Dezimal-Dual-Wandlung ganzer Zahlen (Basis B = 2)

1. Dualzahl auf 0 setzen Wir führen einen Wert I ein, der die gerade bearbeitete Stelle der erzeugten Dualzahl enthält. I wird auf 1 gesetzt.
2. I-te Stelle der Dualzahl := Dezimalzahl mod 2. (Der Operator "mod" bezeichnet den Rest der Division)
3. Dividiere die Dezimalzahl durch 2. Dieser Wert ergibt die neue Dezimalzahl für die Berechnung der nächsten Stelle.
4. Erhöhe den Wert von I um 1. Wenn die Dezimalzahl > 0 ist, fahre fort bei Schritt 2.

Dezimal-Dual-Wandlung echtgebrochener Zahlen (Basis B = 2)

1. Dualzahl auf 0 setzen Wir führen einen Wert I ein, der die gerade bearbeitete Stelle der erzeugten Dualzahl enthält. I wird auf 1 gesetzt.
2. Die Dezimalzahl wird mit der Basis 2 multipliziert. Die I-te Stelle der Dualzahl ergibt sich aus dem ganzzahligen Anteil der Dezimalzahl (Vorkommastelle).
3. Nimm den gebrochenen Anteil der Dezimalzahl (Nachkommastellen) für die weitere Berechnungen.
4. Erhöhe den Wert von I um 1. Wenn die Dezimalzahl > 0 ist, fahre fort bei Schritt 2.

Umwandlung anderes Stellenwertsystem --> Dezimalsystem

Beispiel: Umwandlung aus dem Dualsystem

Z = 101,11 dual = ? dez.

Z = 1 * 2² + 0 * 2¹ + 1 * 2⁰ + 1 * 2^-1 + 1 * 2¹²
= 4 + 0 + 1 + 1/2 + 1/4
= 5,75

Eine andere Möglichkeit ist die Anwendung des Hornerschemas. Beginnend bei der höchstwertigen Ziffer wird bei ganzen Zahlen mit der Basis des Ausgangssystems (dargestellt im Zielsystem) multipliziert und zur nachfolgenden Stelle addiert. Dies wird bis zur niederwertigsten Ziffer fortgesetzt. Das letzte Ergebnis ist die Zahl im Zielsystem.

Dual-Dezimal-Umwandlung, ganzzahlig

1. Setze die Dezimalzahl auf 0. Beginne bei der höchstwertigen Stelle n der Dualzahl. Wir führen einen Wert I ein, der die gerade bearbeitete Stelle der erzeugten Dualzahl enthält. I wird auf n gesetzt.
2. Multipliziere die Dezimalzahl mit 2 und addiere die I-te Stelle der Dualzahl zur Dezimalzahl.
3. Wiederhole Schritt 2 solange, bis alle Stellen der Dualzahl verarbeitet sind.

Beispiel: 11011101 dual = ? dez.

     1   1   0   1   1   1   0   1
 2 * 1 + 1                           = 3 
 2 * 3     + 0                       = 6 
 2 * 6         + 1                   = 13 
 2 * 13            + 1               = 27 
 2 * 27                + 1           = 55 
 2 * 55                    + 0       = 110 
 2 * 110                       + 1   = 221 

      7    C   2
 16 * 7 + 12        = 124 
 16 * 124    + 2    = 1986 

Dual-Dezimal-Umwandlung, echter Bruch

1. Setze die Dezimalzahl auf 0. Beginne bei der niederwertigen Stelle n der Dualzahl. Wir führen einen Wert I ein, der die gerade bearbeitete Stelle der erzeugten Dualzahl enthält. I wird auf n gesetzt.
2. Addiere die I-te Stelle der Dualzahl zur Dezimalzahl und dividiere das Ergebnis durch 2.
3. Wiederhole Schritt 2 solange, bis alle Stellen der Dualzahl verarbeitet sind.

0, 1   0   1   1
               1    / 2 = 0,5 
 (         1 + 0,5) / 2 = 0,75 
 (     0 +    0,75) / 2 = 0,375 
 ( 1 +       0,375) / 2 = 0,6875 

Darstellung negativer Zahlen

In der Datenverarbeitung führt man die Subtraktion auf die Addition einer negativen Zahl zurück. Die Darstellung negativer Zahlen erfolgt durch die sogenannte Komplementdarstellung.

Rückführung der Subtraktion auf die Addition:

              _              _
  a - b = a + b              b ist das Komplement von b

a - b = a + (K - b) - K)

K ist die "Komplementärzahl". Dazu ein Beispiel:

  835               835
 -267       -->    +733   (K - b) = 1000 - 267, K = 1000
------           -------
  568              1568   
                  -1000   (K subtrahieren)
                 -------
                    568

K ist im Prinzip beliebig wählbar, jedoch würde für K = 1000 eine Zahl in Komplementdarstellung nicht von einer natürlichen Zahl unterscheidbar. Wir treffen daher zwei Vereinbarungen:

• Für alle Rechnungen wird eine maximale Stellenzahl n festgelegt.
• Für K wird (im Dezimalsystem) 10ⁿ⁺¹ gewählt. Dann kann man nämlich eine Vorzeichenstelle verwenden. Wir vereinbaren:
  • Vorzeichenstelle = 0: positive Zahl
  • Vorzeichenstelle = 9: negative Zahl
  Die Vorzeichenstelle dient zwar als Indikator für das Vorzeichen, ist jedoch Bestandteil der Zahl!

  835               0835
 -267      -->     +9733
------           --------
  568              10568   
                   ||_____Vorzeichenstelle = 0 --> Erg. positiv 
                   |______Weglassen des ?erlaufs
                   

  267      -->      0267
 -835              +9165
------            -------
 -568               9432 
                    |_____Vorzeichenstelle = 9 --> Erg. negativ 

    Re-Komplement: -0568

 -535               9465
 -267      -->     +9733
------            -------
 -802              19198
                   ||_____Vorzeichenstelle = 9 --> Erg. negativ
                   |______Weglassen des ?erlaufs

    Re-Komplement: -0802

Zunächst eine allgemeine Definition. Es sind zwei Arten von Komplementen gebräuchlich. X sei eine n-stellige positive Zahl im Zahlensystem zur Basis B, dann ist:

                                         _    n+1
     B-Komplement (Zweierkomplement):    X = B    - X
     ("echtes Komplement")
                                         _     n+1
     (B-1)-Komplement (Einerkomplement): X = (B    - 1) - X
     ("unechtes Komplement, Stellenkomplement")

• Einerkomplement bilden und dann 1 addieren:

            0110 1100          X
            1001 0011          1-Kompl.
         +          1          addieren
            1001 0100          2-Kompl.
  

• Direkt: ?ernahme aller Stellen von rechts bis zur ersten 1 einschließlich, alle weiteren Stellen invertieren:

            0110 1100          X
            1001 0100          übernehmen/invertieren
            1001 0100          2-Kompl.
   

• Wertebereich bei n Stellen: -2^n-1 bis +2^n-1 - 1

  Beispiel: 4 Stellen

       0111 +7
       0110 +6
       0101 +5
       0100 +4
       0011 +3
       0010 +2
       0001 +1
       0000  0
       1111 -1
       1110 -2
       1101 -3
       1100 -4
       1011 -5
       1010 -6
       1001 -7
       1000 -8        
  

Die Gesamtheit der so dargestellten Zahlen nennt man konegative Zahlen (gesprochen "ko-negativ", kommt von "Komplement-negativ"). Der Vorteil der Komplementdarstellung von negativen Zahlen liegt in der Ausführbarkeit der Subtraktion als Addition.

Addiert man die beiden vierstelligen Dualzahlen 0101 und 0100, ergibt sich 1001, also -7. Das ist sicher falsch. Grund dafür ist die Überschreitung des zulässigen Zahlenbereichs. Welche Ergebnisse der Addition/Subtraktion nicht im darstellbaren Zahlenbereichzeigt folgende Tabelle:

Merksatz: Wenn beide Operanden das gleiche Vorzeichen haben und das Ergebnis ein davon abweichendes Vorzeichen, dann gab es eine Bereichsüberschreitung (Overflow).

Die bisher gesammelten Erkenntnisse führen dann zur Rechenvorschrift für die Subtraktion durch Komplementaddition (B-Kompl.):

1. Stellenzahl von X und Y angleichen
2. B-Komplement X_k des Subtrahenden X bilden
3. Y und X_k addieren
4. Eventuellen ?ertrag streichen
5. Ist VZ-Stelle von Y = VZ-Stelle von X und unterscheidet sie sich von der VZ-Stelle des Ergebnisses, dann ist ein Zahlenbereichsüberlauf aufgetreten --> Fehlermeldung.
6. Ist die VZ-Stelle des Ergebnisses = 0, dann ist das Ergebnis positiv, sonst ist das Ergebnis negativ (in B-Komplement-Darstellung). Will man in diesem Fall den Betrag des Ergebnisses feststellen, muß man das Ergebnis komplementieren.

Festpunkt- und Gleitpunktdarstellung

Festpunktzahlen

Darstellung mit Vorzeichen, 8 Stellen vor dem Komma und 3 Stellen dahinter (dezimal).

Die Zahl wird mit führenden Nullen dargestellt und gegebenenfalls gerundet. Im obigen Beispiel reicht der darstellbare Bereich von -99999999,999 bis +99999999,999. Der Nachteil liegt im begrenzten Zahlenbereich --> bei sehr kleinen Zahlen gehen durch die Rundung Stellen verloren (0,0009 würde z. B. zu 0), sehr große Zahlen sind nicht mehr darstellbar.

Gleitpunktzahlen

Bei der Gleitpunkt-Darstellung wird die Zahl so gespeichert, daß der Radixpunkt immer zur ersten von Null verschiedenen Ziffer gleitet. Dies erreicht man durch Abspalten einer entsprechenden Potenz der Basis:

Z = M * B^E

M = 0.xxxxxxx.... 1/B <= M < 1

Da die Basis bekannt ist, kann die Zahl durch die Mantisse M und den Exponenten E dargestellt werden. --> halblogarithmische Darstellung --> normalisierte Darstellung. Die Anpassung der Gleitpunkt-Zahl an die angegebene Darstellungsform wird als "Normalisieren" bezeichnet. Beispiel:

Z = 42.5456 --> 0.425456 * 10² --> M = 425456, E = 2

Exponent: (bzw. Charakteristik) Größenordnung der Zahl
Mantisse: Angabe der gültigen Zifferndarstellungen

Die Art der Darstellung von Mantisse und Exponent ist recht unterschiedlich. Für Mantisse und Exponent wird jeweils eine feste Stellenzahl vorgegeben, in der auch das Vorzeichen von Mantisse und Exponent untergebracht werden muß. Am üblichsten ist Betrags-Vorzeichen-Darstellung der Mantisse und Exponentendarstellung mit verschobenem Wertebereich (Charakteristik) so, daß der Wert der Charakteristik immer positiv ist. Sie stellt also eine einfache Verschiebung des Wertebereichs dar und hat keinen Einfluß auf die Berechnung. Beispiel:

Umwandlung einer Dezimalzahl in eine Gleitpunkt-Dualzahl:

1. Methode:
   • Getrennte Umwandlung des ganzahligen und gebrochenen Anteils
   • Verschieben des Radixpunktes bis zur ersten von Null verschiedenen Ziffer (Normalisierung).
   Beispiel (8 Stellen Mantisse, 4 Stellen Exponent, V = 8):
   27.75 dez. = 11011.11 dual
   --> M=0.1101111, E=0101
   --> M=0.1101111, C=1101

2. Methode:
   • Abspalten der nächstgrößeren Zweierpotenz (d.h. dividieren durch 2, bis das Ergebnis kleiner 1 ist)
   • Getrennte Umwandlung von Mantisse (echter Bruch) und Exponent (ganzzahlig).
   Beispiel (8 Stellen Mantisse, 4 Stellen Exponent, V = 8):
   27.75 dez. --> M = 0.8671875, E = 5
   --> M = 0.1101111, E = 0101
   --> M = 0.1101111, C = 1101

Allgemein gilt:

• Die Gleitkommadarstellung ist immer auf eine bestimmte Zahl von Stellen genau (die Anzahl der Mantissenstellen) --> bestimmte relative Genauigkeit, z.B. 32-Bit-Mantisse (einschl. VZ) --> 31 Dualst. --> 9 Dezimalstellen. Reelle Zahlen werden also immer auf die nächstgelegene GK-Zahl gerundet.
• Die GK-Darstellung hat den Vorteil, daß man mit bestimmter Stellenzahl einen viel größeren Zahlenbereich darstellen kann, als mit Fixkommazahlen.
• Manchmal wird auch eine Darstellung verwendet, bei welcher der Radixpunkt rechts der ersten von Null verschiedenen Ziffer steht (z.B. 1.100101). Im Dualsystem ist diese Ziffer immer 1 und kann deshalb bei der Speicherung in EDV-Systemen weggelassen werden (impliziter ganzer Teil der Mantisse).

Gleitpunkt-Arithmetik

• Addition und Subtraktion:
  1. Angleichen der Exponenten der beiden Operanden (Verschieben der Mantisse des Operanden mit kleineren Exponenten)
  2. Addition/Subtraktion der Mantissen
  3. Normalisieren des Ergebnisses
• Multiplikation und Division:
  1. Multiplikation/Division der Mantissen
  2. Addition/Subtraktion der Exponenten
  3. Normalisieren des Ergebnisses
• Assoziativität und Distributivität gilt nicht mehr:
  Durch die begrenzte Stellenzahl entstehen u. U. Rundungsfehler beim Angleichen der Operanden (Rundungsfehler). Das Assoziativgesetz und das Distributivgesetz gelten nicht mehr.

  a + (b + c) != (a + b) + c 
  a * (b * c) =/ (a * b) * c 
  (a + b) * c =/ (a * c) + (b * c) 
  

  Einfaches Beispiel im Dualsystem: 10,11 + 11101,0
  0 | 0 0 0 1 | 1 0 1 1 0 0
  0 | 1 1 0 1 | 1 1 1 0 1 0
  1. Schritt (angleichen):
  0 | 1 1 0 1 | 0 0 0 1 0 1 (1)
  0 | 1 1 0 1 | 1 1 1 0 1 0
  

  Schon beim Angleichen geht die letzte Stelle des ersten Summanden verloren.

Informationsdarstellung in Rechenanlagen

Integer-Zahlen

Real-Zahlen

Zeichen

• EBCDIC (Extended Binary Code for Digital InterChange)
• CDC-Display-Code (6-Bit): CDC-Cyber, keine Kleinbuchstaben
• 12-Bit Lochkarten-Code: Zur Darstellung von Informationen auf Lochkarten

• Reservierung des Speicherplatzes für einen String der maximal vorgegebenen Länge (= Anzahl der Codeworte). Die Anzahl der gültigen Zeichen wird im ersten Codewort gespeichert.
• Bei einem String der Länge n Reservierung von n+1 Codeworten. Das letzte Codewort enthält ein speziellen Abschlusszeichen (z.B. Nullwort)

ASCII Tabelle (sedezimal)

| 00 nul| 01 soh| 02 stx| 03 etx| 04 eot| 05 enq| 06 ack| 07 bel|
| 08 bs | 09 ht | 0a nl | 0b vt | 0c np | 0d cr | 0e so | 0f si |
| 10 dle| 11 dc1| 12 dc2| 13 dc3| 14 dc4| 15 nak| 16 syn| 17 etb|
| 18 can| 19 em | 1a sub| 1b esc| 1c fs | 1d gs | 1e rs | 1f us |
| 20 sp | 21  ! | 22  " | 23  # | 24  $ | 25  % | 26  & | 27  ' |
| 28  ( | 29  ) | 2a  * | 2b  + | 2c  , | 2d  - | 2e  . | 2f  / |
| 30  0 | 31  1 | 32  2 | 33  3 | 34  4 | 35  5 | 36  6 | 37  7 |
| 38  8 | 39  9 | 3a  : | 3b  ; | 3c  < | 3d  = | 3e  > | 3f  ? |
| 40  @ | 41  A | 42  B | 43  C | 44  D | 45  E | 46  F | 47  G |
| 48  H | 49  I | 4a  J | 4b  K | 4c  L | 4d  M | 4e  N | 4f  O |
| 50  P | 51  Q | 52  R | 53  S | 54  T | 55  U | 56  V | 57  W |
| 58  X | 59  Y | 5a  Z | 5b  [ | 5c  \ | 5d  ] | 5e  ^ | 5f  _ |
| 60  ` | 61  a | 62  b | 63  c | 64  d | 65  e | 66  f | 67  g |
| 68  h | 69  i | 6a  j | 6b  k | 6c  l | 6d  m | 6e  n | 6f  o |
| 70  p | 71  q | 72  r | 73  s | 74  t | 75  u | 76  v | 77  w |
| 78  x | 79  y | 7a  z | 7b  { | 7c  | | 7d  } | 7e  ~ | 7f del|

Latin1-Tabelle

Logische Werte

• ungepackte Darstellung: Ein logischer Wert wird in einem Byte oder auch einem Maschinenwort gespeichert (große Platzverschwendung). Die Zuordnung ist oft: "WAHR" ungleich 0, "FALSCH" = 0.
• gepackte Darstellung: Jedes einzelne Bit des Maschinenworts repräsentiert einen logischen Wert, also 8 Werte/Byte.

4.2 Elementare Typen, Qualifizierer, Speicherklassen

Elementare Datentypen

Speicherklassen

int y = 1;     /* global */   
int main(void)
  { 
  int x = 5; /* lokal */

  printf("x=%d\n",x);    /* Ausgabe: 5 */
    { 
    int x=10;
    printf("x=%d\n",x);  /* Ausgabe: 10 */
    }
  printf("x=%d\n",x);    /* Ausgabe: 5 */
  }

void print(void);

int main(void)
  { 
  int x=5;
  print();
  }

void print(void)
  { 
  printf("x=%d\n",x);
  }

#include <stdio.h>
#define MAXCHARS 255

int count[MAXCHARS];         /* global */

void print_alle (void);

void main(void)
  { 
  extern int count[];        /* Deklaration von count */
  int c;
  while((c=getchar()) != EOF)
    count[(char) c]++ ;
  print_alle();
  }

void print_alle(void)        /* kann z. B. in einer anderen Datei stehen */
  { 
  extern int count[];        /* Deklaration von count */
  int i;

  for(i = 0; i < MAXCHARS; i++)
    printf("%d: %d\n",i,count[i]);
  }

#include <stdio.h>

char *monatsname(int);  /* Gibt Zeiger auf ein Feld zurueck */

int main(void)
  { 
  int i;
  for(i = 1; i <= 12; i++)
    printf("%s\n",monatsname(i));
  }

char *monatsname(int n)
  { 
  static char *name[] = {"falscher Monat",
                         "Januar", 
                         "Februar",
                         "Maerz", 
                         "April", 
                         "Mai",
                         "Juni",
                         "Juli", 
                         "August",
                         "September",
                         "Oktober",
                         "November", 
                         "Dezember"
                         }; 
    if ((n < 1) || (n > 12))
      return(name[0];
    else
      return(name[n]);
    }

Qualifizierer

Außer eventuell bei char sind diese Größen nicht festgelegt, sondern abhängig vom jeweiligen Compiler. Definitiv festgelegt sind die angegebenen Mindestgrößen und die folgenden Relationen:
short <= int <= long;
float <= double <= long double.
Die tatsächliche Größe kann man den Header-files <limits.h> und <float.h> entnehmen.

4.3 Konstanten

1. Ganzzahlig
   • dezimal: -1, 0, 2001, ...
   • oktal: (beginnt mit 0) 020, 01, 0777, ...
   • hexadezimal: (beginnt mit `0x') 0x5F, 0xF7A, ...
   Diese Konstanten gelten als signed int; sollen sie dagegen vom Typ unsigned, long oder unsigned long sein, müssen sie durch Anhängen von u oder U, bzw. l oder L als solche spezifiziert werden (z. B.:54000UL).

2. Gleitpunkt:
   • mit Dezimalpunkt oder Exponent: 3.141592 2.9979e8, 6e-31, ...
     (e oder E)
   • Solche Konstanten sind automatisch double, wenn nicht F oder f (für float) bzw. L oder l (für long double) folgt.

3. Zeichenkonstanten:
   • zwischen ' ' eingeschlossen: 'a', 'B', '\n', '\0', ...
   • Zeichenkonstante können auch durch ihren Code angegeben werden:
     \nnn dezimal, z. B. \053 für '+' oder
     \0xnnn sedezimal, z. B. \0x40 für '@'.

4. Konstante Zeichenketten (sog. Strings):
   • zwischen " " eingeschlossen:
     "ich bin ein String\n",
     "Dieser Text piept!\a", ...
     
   • Zeichenkettenkonstante werden automatisch mit einem Nullbyte (\0) abgeschlossen.
     "A" belegt also zwei Speicherplätze, für 'a' und für '\0'.

Neben der Verwendung von Konstanten in beliebigen Anweisungen (z. B. if (a > 1.0) oder Nachname := "unbekannt";) besteht in C die Möglichkeit, Bezeichner für Konstante zu vergeben.
Bei der Programmiersprache C findet man zwei Varianten der Konstantenvereinbarungen:

const Pi = 3.1415
#define Pi 3.1415

Wichtig:Bei der Verwendung von Gleitpunktkonstanten muß der Dezimalpunkt angegeben werden. 2000 ist eine Integer-Konstante, 2000. oder 2000.0 sind Gleitpunkt-Konstante (float oder double).

4.4 Aufzählungstypen mit enum

/* Aufzaehlung */
enum lichtzeichenanlage {rot, gelb, gruen};

enum wochentag {MO, DI, MI, DO, FR, SA, SO} termin;    
enum wochentag  ruhetag;        
enum lichtzeichenanlage ampel;

termin = DI;
ruhetag = FR;
ampel = rot;

Es lassen sich auch alle Werte individuell belegen, wobei auch mehrere Konstanten den selben Wert besitzen dürfen (was aber selten sinvoll ist).
enum lichtzeichenanlage {rot = 10, gelb = 20, gruen = 30};

4.5 Arithmetische Operatoren

if (z = x + y) { .... }

z = x + y;
if (z) { ... }

Da die Zuweisung ein Operator ist, sind auch Mehrfachzuweisungen wie z. B. a = b = c = 12 möglich. Die Zuweisung bindet schwächer als andere Operatoren (arithmetische oder Vergleichs-Operatoren). Daher sollte man Zuweisungen, die in Ausdrücken stehen, zur Sicherheit klammern. Erst durch den abschließenden Strichpunkt wird der Zuweisungsoperator zu einer Anweisung!

Es gibt sechs arithmetische Operatoren. Sie stehen für die vier Grundrechenarten (+ - * /), die Modulofunktion (Rest nach Division; % ) und die arithmetische Negation (das Vorzeichen).

Die Modulofunktion ist nicht auf float oder double Operanden anwendbar. Die Rangfolge ist wie gewohnt: *, / und % gleich und höher als + und -. Das Minuszeichen als unärer Operator (Vorzeichen) hat einen höheren Vorrang als *, / und %. Es gibt kein positives Vorzeichen.

Beispiele für die Anwendung arithmetischer Operatoren:

int h, i=3, j=5, k=10;
float x, y=5.0, z=3.0;
h = i+j+k;              /* 18 */
h = k-j-i;              /*  2 */
h = i-k;                /* -7 */
h = k/i;                /*  3 */
h = k/i+j;              /*  8 */
h = k/(i+j);            /*  1 */
h = k*i+j;              /* 35 */
h = k*(i+j);            /* 80 */
h = k%i;                /*  1 */
x = y+z;                /* 8.       */
x = y/z;                /* 1.666... */
x = y*z;                /*15.       */
x = k/z;                /* 3.333... */
x = k/z + y/z;          /* 5.       */
x = k/i + y/i;          /* 4.666... */
x = k%z;                /* verboten! */

Höhere Rechenoperationen wie Wurzelziehen, Potenzieren, Exponentiation, usw. fehlen in C als Operator ganz; sie sind über Bibliotheksfunktionen realisiert. Bei ihrer Verwendung muß in jedem Fall die Inlcude-Datei math.h mit eingebunden werden.

Inkrement- und Dekrementoperatoren

Sie sind (wie der Vorzeichenoperator -) rechts assoziativ, werden also von rechts her zusammengefaßt. Sie können vor oder nach ihrem Operanden stehen. Im ersten Fall wird der Operand zunächst in- oder dekrementiert und dann weiterverwendet, im zweiten Fall wird der Operand erst verwendet und dann in- oder dekrementiert.

int i;
int k;
i=1;
if (++i > 1)
    k = 5;            /* wird durchlaufen */
if (i++ > 2)
    k = 10;           /* wird nicht durchlaufen */

Logische Verknüpfungen

Sie sind hier in ihrer Rangfolge geordnet aufgeführt, logisches UND hat also einen höheren Vorrang als das logische ODER. In Ausdrücken erfolgt die Abarbeitung von links nach rechts aber nur solange, bis das Ergebnis eindeutig feststeht. Das führt zu einer kürzeren Ausführungszeit, wenn man die häufigst verwendete Bedingung an den Anfang einer Bedingungsabfrage stellt. Bei Operationen, die Nebeneffekte haben können (z.B. Inkrementation), muß man allerdings vorsichtig sein.

if (a<b         &&  (d=(a+b)) != c)   /* diese 2 Zeilen */
if ((d=(a+b)) != c &&  a<b)           /* wirken nicht gleich */

Beispiel:

#include <stdio.h>

int main (void)
  {
  enum logik { false = 0, true = 1} a, b;

  printf ("| a b | a&&b | a||b |\n");
  printf ("|-----|------|------|\n");
  for (a = false; a <= true; a++)
    for (b = false; b <= true; b++)
      printf ("| %d %d |   %d  |   %d  |\n",a, b, (a && b), (a || b));
  return 0;
  }

Ergebnis:

     | a b | a&&b | a||b |
     |-----|------|------|
     | 0 0 |   0  |   0  |
     | 0 1 |   0  |   1  |
     | 1 0 |   0  |   1  |
     | 1 1 |   1  |   1  |

Bitmanipulationen

C stellt auch Operatoren für Bitmanipulationen zur Verfügung. Die Verknüpfung der beiden Operanden erfolgt bitweise. Sie können nicht auf Variablen oder Konstanten vom Typ float oder double angewendet werden. Die Operatoren sind:

Beispiele:

int i=7;
int j=9;
int k;
k = i & j;        /* k=1   */
k = i | j;        /* k=15  */
k = i ^ j;        /* k=14  */
k = ~0            /* k=max(unsigned int) */
k = ~i;           /* k=max(unsigned int) -7 */
k = i << 3;       /* k=56  */
k = i >> 3;       /* k=0   */
k = i & 0x03;     /* k=3; alle Bits bis auf die beiden */
                  /* unteren ausmaskiert */

Beispiel: Zählen der Anzahl der 1-Bits in n

bitcount(unsigned int n)
  {
  int b;
  for (b=0; n!=0; n >>= 1)
  if (n & 01)
    b++;
  return (b);
  }

bitcount(unsigned int n)
  {
  int b;
  b=0;
  while (n != 0) 
    {
    b++;
    n = n & (n-1);
    }
  return (b);
  }

Das folgende Beispiel ermittelt die Länge eines Maschinenwortes durch Zählen der Bits.

#include <stdio.h>

int wordlen()
  {
  int i; 
  unsigned wort;
  i = wort = 0;
  wort = ~wort;  /* alle Bits auf 1 setzen */
  while (wort != 0) 
    {
    wort = wort >> 1;  /* rechtsschieben */
    i++;
    }
  return(i);
  }
main()
  {
   printf("Anzahl der Bits: %d\n",wordlen());
  }

Die folgenden "Einzeiler" manipulieren jeweils ein bestimmtes Bit in einem Integer-Wort:

/* Teste, ob ein bestimmtes Bit 0 oder 1 ist */
int tstbit( int word, int bit ) { return (word & (1 << bit) != 0); }

/* Loesche ein bestimmtes Bit */
int clrbit( int word, int bit ) { return (word & ~(1 << bit)); }

/* Setze ein bestimmtes Bit */
int setbit( int word, int bit ) { return (word | (1 << bit)); }

/* Invertiere ein bestimmtes Bit */
int xorbit( int word, int bit ) { return (word ^ (1 << bit)); }

Wichtig:

• es werden teilweise die gleichen Operatorzeichen für verschiedene Operatoren verwendet

  Operator- zeichen	1. Bedeutung	2. Bedeutung
  ()	Klammerung	typecast
  *	Pointerdeklaration	Multiplikation
  -	Vorzeichen	Subtraktion
  &	Adresse von	bitweises UND

• Inkrement- und Dekrementoperatoren haben einen sehr hohen Vorrang
• die Arithmetikoperatoren haben einen Vorrang wie erwartet und gewohnt
• Shifts haben einen höheren Vorrang als Vergleiche, im Gegensatz zu den anderen Bitmanipulationen, die nach den Vergleichen stehen.
• bitweise logische Operationen stehen vor den logischen Operationen, die sich auf ganze Zahlen beziehen.
• die bedingte Bewertung hat einen sehr niedrigen Vorrang, trotzdem sollte man sich bei ihrer Anwendung eine Klammerung angewöhnen, damit die Anweisung leichter lesbar ist.
• außer durch den Vorrang ist die Reihenfolge der Bewertung undefiniert: z = (a*2) + ++a kann als (a*2)+ ++a aber auch als ++a + (a*2) bewertet werden. Seiteneffekt!
• ebenso ist die Reihenfolge der Bewertung von Funktionsparametern nicht gewährleistet:

  i=1;
  printf("%d %d",++i,i*3)   /* kann 2,6 oder 4,3 ausgeben */
  

• ebenfalls nicht eindeutig definiert ist folgende Konstruktion: a[i]=i++;
• Dagegen bedeutet x---y: x-- - y und nicht x - --y. Der Compiler führt seine lexikalische Analyse immer von links nach rechts aus und nimmt dabei soviele Zeichen, wie er nur kann, um ein Token zu bilden.

4.6 Logische Datentypen und Operatoren, Vergleiche

Die ersten vier haben untereinander gleichen Rang, stehen aber eine Rangstufe höher als die beiden letzten. Es gibt in C grundsätzlich keinen Datentyp BOOLEAN; WAHR oder FALSCH werden einfach über den numerischen Integer-Wert entschieden. Dabei gilt:

Arbeitet man in einem Programm viel mit diesen Werten, kann man folgende Konstantendefinitionen zu benutzen:

    #define FALSE  0
    #define TRUE   ! FALSE

Beispiele für die Verwendung dieser Operatoren:

int a=5;
int b=12;
int c=7;
   a < b                /* WAHR   */
   b < c                /* FALSCH */
   a+c <= b             /* WAHR   */
   b-a >= c             /* WAHR   */
   a == b               /* FALSCH */
   a+c == b             /* WAHR   */
   a != b               /* WAHR   */
   a = b<c;             /* möglich: a=0 */
   a = c<b;             /*   -"-    a=1 */

Wie schon erwähnt, bindet die Zuweisung schwächer als andere Operatoren (arithmetische oder Vergleichs-Operatoren). Daher sollte man Zuweisungen, die in Ausdrücken stehen, zur Sicherheit klammern. Dazu einige Beispiele:

if (x = y)
   tuwas();

1. Es soll wirklich x mit y verglichen werden. Dann darf nicht "=" stehen, sondern der Vergleichsoperator "==". Solche Flüchtigkeitsfehler kommen oft vor.

   if (x == y) /* Vergleich x == y (doppeltes Gleichheitszeichen) */
     tuwas();
   

2. Es soll tatsächlich die Zuweisung x = y erfolgen und abhängig vom Wert der Variablen x bzw. y verzweigt werden. Dann ist zwar if (x = y) richtig, aber der Deutlichkeit halber sollte man schreiben:

   if ((x = y) != 0)
     tuwas();
   

   Die Klammerung von (x = y) ist notwendig, da der Vergleichoperator stärker bindet als die Zuweisung. Fehlt die Klammer, wäre das schon wieder ein schwer zu findender Fehler. x = y != 0 bedeutet: x = (y !=0). x hätte nachher nicht den Wert von y, sondern 0 oder 1.

4.7 Zusammengesetzte Operatoren, implizite Typumwandlung

Zusammengesetzte Operatoren

Ausdruck1 op= Ausdruck2

Ausdruck1  =  (Ausdruck1) op (Ausdruck2)

i *= k+1;      /* wird wie */
i = i * (k+1); /* behandelt und nicht wie */
i = i * k +1;

Der Vorteil der abgekürzten Schreibweise wird an folgendem Beispiel deutlich:

feld[i*3+j-7] = feld[i*3+j-7] + 10;     /* normal */
feld[i*3+j-7] += 10;                    /* abgekürzt */

Zusammengesetzte Zuweisungsoperatoren:

Implizite Typumwandlung

• char wird bei Bewertungen immer in int gewandelt, dadurch sind int und char beliebig mischbar. Allerdings kann die char-int Wandlung rechnerabhängig sein, char kann auf die Zahlenwerte -128 bis +127 oder 0 bis +255 abgebildet sein, die "normalen" Zeichen liegen aber immer im positiven Bereich. Die char-int Wandlung ist vor allem bei der Abfrage eines eingelesenen Zeichens auf EOF wichtig (Eingelesen werden immer int Werte, die dann aber einfach char Werten zugewiesen werden können).
• die Wandlung von int nach long erfolgt durch Vorzeichenerweiterung (bei signed) oder Voranstellen von Nullen (unsigned), bei der umgekehrten Wandlung werden die höchstwertigen Bits einfach abgeschnitten.
• float wird bei Bewertungen immer in double gewandelt, alle Rechnungen erfolgen daher mit derselben großen Genauigkeit. Die Wandlung von int nach float ist wohldefiniert, die umgekehrte Richtung kann rechnerabhängig sein, insbesondere bei negativen Gleitkommazahlen.

Zusammenfassung:

Bei Parameterübergabe an Funktionen erfolgt die Umwandlung des Typs des aktuellen Parameters in den Typ des formalen Parameters nach obigen Regeln.

Den genauen Ablauf der Wandlungen bei der Auswertung eines Ausdrucks oder einer Zuweisung beschreiben folgende Regeln (übliche arithmetische Umwandlungen):

• Zuerst werden char oder short Operanden in int Werte und float Operanden in double Werte umgewandelt.
• Hat jetzt ein Operand den Typ double, so wird der andere ebenfalls in double gewandelt und das Resultat ist auch double.
• Ist stattdesssen einer der Operanden long, so wird der andere auch in long gewandelt und das Resultat ist auch long.
• Ist andernfalls einer der Operanden unsigned, so wird auch der andere in unsigned gewandelt und das Resultat ist ebenfalls unsigned.
• Liegt keiner dieser Fälle vor, so handelt es sich um int-Werte, diesen Typ hat dann natürlich auch das Resultat.

Beispiel:

Vorsicht:

• Division zweier int ergibt wieder int, also den Ganzzahlanteil des mathematischen Wertes.
• Bei Umwandlung von höherwertigem zu niederwertigem Datentyp ist Informationsverlust möglich!
• Achtung bei Vergleich von signed und unsigned Typen!
  Beispielsweise könnte WAHR sein: -1 > 1U

Explizite Typumwandlung (type cast)

int j = 12, k = 18;
float f;
   ...
f = k/j;    /* in f steht 1.0 */
   ...

Die explizite Typumwandlung (type cast) erfolgt mittels des Cast-Operators, der unmittelbar vor den Ausdruck zu setzen ist, dessen Typ konvertiert werden soll. Der Cast-Operator ist ganz einfach eine in Klammern gesetzte Typangabe. Obiges Beispiel wird geändert zu:

int j = 12, k = 18;
float f;
   ...
f = (float)k/j;
   ...

Beispiel: Wandelt die nächsten x Ziffern aus dem String s in eine Integerzahl

atoi(char s[])    
  {
  int i,n;
  n=0;
  for (i=0; s[i]>='0' && s[i]<='9'; i++)
    n = 10*n + s[i]-'0';
  return (n);
  }

Beispiel: Wie atoi, aber für Hexadezimalzahlen.

htoi(char s[])
  {
  int i,n;
  n=0;
  for (i=0; ; i++)
  if (s[i] >= '0' && s[i] <= '9')
    n = 16*n + s[i]-'0';
  else if (s[i] >= 'A' && s[i] <= 'F')
         n = 16*n + s[i]-'A'+10;
  else if (s[i] >= 'a' && s[i] <= 'f')
         n = 16*n + s[i]-'a'+10;
  else 
    break;
  return (n);
  }

Copyright © FH München, FB 04, Prof. Jürgen Plate

Letzte Aktualisierung: 19. Nov 2004