/*
     KONSTRUKTION NEUER DATENTYPEN AUS DEN BASISTYPEN

     ARRAYS (deutsch 'Felder') erzeugen eine Menge von 
     Variablen gleichen Typs,
     die mit Hilfe eines INDEX angesprochen werden. Der Index
     ist eine  ganze Zahl im Bereich 

              0,1,...,"Länge des Arrays - 1"

     Die Deklarationssyntax ist

        <datentyp> <variablenname>[<Laenge des Arrays>];
     
     <Laenge des Arrays> wird als DIMENSION des Arrays
     bezeichnet.

     Arrays können mit der Notation
 
         { wert0, wert1, ..., wert"Länge des Arrays - 1" }

     initialisiert werden.

     Aus mathematischer Sicht ist ein Array
            array_typ a_name[dimension]
     eine Funktion 
 
            a_name : { 0,1,...,(dimension-1)} --> array_typ
     

     Der zweite Typkonstruktor ist die STRUKTUR

       struct { 
          typ1 komponente1;
          ...
          typ_n komponente_n;
       }  x;

     x ist eine STRUKTURIERTE Variable: Jeder Wert von
     x besteht aus n Komponenten. Die Komponente i ist
     vom Typ typ_i. Der Zugriff auf die Komponenten von
     x erfolgt durch den Selektor "." :

        mit x.komponente_i
        wird die i-te x-Komponente angesprochen.

     Mathematisch gesehen ist eine Struktur x vom Datentyp

         KREUZPRODUKT

         typ_1 x typ2 x ... x typ_n

     Die Selektion x.komponente_i entspricht der 
     PROJEKTIONSFUNKTION auf die i'te Komponente

      x.komponente_i : typ_1 x typ2 x ... x typ_n -> typ_i

 
     Der dritte Typkonstruktor ist der AUFZÄHLUNGSTYP
     (eng. Enumeration Type):

     enum { rot, gruen, blau } farbe;

     deklariert eine Variable 'farbe', welche die
     abstrakten Wertbezeichnungen rot, gruen, blau haben darf.
     In C haben die Aufzählungswerte rot, gruen, blau den 
     "internen" Wert ganzer Zahlen: Die Nummerierung erfolgt
      von 0 an aufsteigend. Falls gewuenscht, lassen sich den
     Aufzählungswerten auch explizit Werte zuweisen:

     enum { mauve = 4, pink = 9 } neue_farbe.

     printf() verwendet nur den int-Wert des Aufzählungstyps,
     kann also die abstrakte Bezeichnung nicht ausgeben.


     Neu konstruierte Datentypen lassen sich wiederverwenden:
     Sie erhalten mit der typedef-Anweisung einen Namen, der
     dann anstelle der expliziten Typdeklaration bei der
     Variablendeklaration verwendet werden kann:


     Die Typdeklaration hat die Struktur

     typedef <Typspezifikation> <Typname>;

     typedef enum { rot, gruen, blau } basic_colours_t;
     
     basic_colours_t farbe;

     

     */
 

#include <stdio.h>
     
typedef struct  {
	float my_float;
        int   i;
        char  s[20];
} sample_struct_t;

typedef enum { rot, gruen, blau } basic_colours_t;

int main() {

    float x;
    float y;
    int   i;
    char  a;
 
    basic_colours_t farbe;

    /* ein Array von float-Zahlen:
       Index-Bereich 0..4 */
    float f_array[5] = { 1.3, 2.4, 2.6, 2.7, 6.6 };
    enum { mauve = 4, pink = 9 } neue_farbe;

    /*
     Zur Bearbeitung von Zeichenketten werden Strings verwendet;
     dies sind char-arrays, bei denen das letzte Zeichen den
     Wert 0 (alle 8 Bits == 0) hat.

     Die Initialisierung kann durch 
          { 'm', 'y', .... }
     oder durch die Zeichenkette in " ... "-Notation
     */
    char myString[16] = "my first string";

    /* strukturierter Typ */
    sample_struct_t xs = { 34.6, 7, "another string"  };


    neue_farbe = mauve;

    if ( neue_farbe != pink ) {
       printf("neue_farbe == %d\n",neue_farbe);
    }
 
    /* Array-Elemente werden durch ihren Index identifiziert*/  
    f_array[4] = 5.7;

    printf("f_array[3] = %f f_array[4] = %f\n",
            f_array[3], f_array[4]);


    /* Strings: char-Arrays, in denen auf die Zeichenkette
       ein 0-Byte folgt */ 
    printf( "1. Zeichen = %c\n", myString[0]);
    printf( "vorletztes Zeichen = %c\n", myString[14]);
    printf( "letztes Array-Element %d\n", myString[15]);


    /* dies geht schief, weil die 0-Terminierung fehlt: */
    myString[15] = 'P';
    printf("myString = %s\n", myString);
   

    /* Strukturen */ 
    printf(" xs.my_float = %f\n", xs.my_float);
    printf(" xs.i = %d\n", xs.i);
    printf(" xs.s = %s\n", xs.s);

    xs.s[3] = 's';
    xs.s[4] = 's';
    printf(" xs.s = %s\n", xs.s);

}