Sprachelemente

Grundelemente:

• Programmtext in freier Form, ohne Zeilenstruktur
• Groß- und Kleinbuchstaben werden unterschieden
• Kommentar: /* erklaer mal was */
• Anweisungen werden mit ; abgeschlossen

Datentypen:

• Einfache Datentypen:
  • ganze Zahlen: char, short, int, long
  • Fließkommazahlen: float, double, long double
  • Zeichen: char (Abspeicherung als kleiner Integer, meist 1 Byte)
  • Logische Größen: nicht vorhanden
    Ersatz: ganze Zahlen ( $0 \; \ensuremath{\hat{=}}$ false, $(\neq 0) \; \ensuremath{\hat{=}}$ true)

• Felder:
  • Vereinbarung eines Feldes von 100 double-Werten:
       double a[100];
          
    
    
  • Zugriff auf die Elemente durch ganzzahligen Index:
       a[6] = 2.71828;
          
    
    

    erstes Element ist a[0]

  • keine Tests auf Index-Überschreitung
  • Mehrdimensionale Felder:
       double a[1000][1000][1000];  /* gib mir 8 GB! */  
          
    
    

    Speicherreihenfolge: a[0][0][0], a[0][0][1] ..
    (erst Zeilen, dann Spalten)

• Zeichenketten:
  • Felder von Zeichen, abgeschlossen durch ein NULL-Zeichen ('$\backslash 0$')
  • Konstante:
       char littleString[] = "juhu";
          
    
    
  • Initialisierung:
       char myString[] = "joobar";  /* 7 Zeichen lang! */
          
    
    

• Strukturen:
  • Definition des neuen Typs:
       struct Person {
         char    name[20];
         int     alter;
         float   groesse;
       }
          
    
    
  • Benutzen:
       struct Person mrPresident = {"Bill", 53, 1.78};
       mrPresident.height = mrPresident.height - 0.03;  /* tjaja, das Alter */
       mrPresident.alter++;        /* Geburtstag */
          
    
    

• Zeiger:
  • Adressoperator & (Zeiger auf ein Objekt)
  • Inhaltsoperator * (Inhalt eines Zeigers)
  • Beispiel:
       double  a = 2.7;
       double  * pointer;
    
       pointer = &a;      /* pointer zeigt auf a */
       *pointer = 3.1;    /* Inhalt von pointer wird gesetzt */
                                 /* a hat den Wert 3.1 ! */
          
    
    
  • generischer Zeigertyp (void *) : darf auf alles zeigen
  • dynamischer Speicher mit Standardfunktionen:
       double * a;
       a = (double *) malloc(1000 * sizeof(double));
       a[100] = 28.8;
       free(a);
          
    
    Speicherverwaltung per Hand - fehlerträchtig!

Kontrollstrukturen:

• Block:
     {
       Anweisung1
       Anweisung2
         ...
     }
      
  
  

• Bedingte Anweisung:
     if (Bedingung)
       Anweisung1
     else
       Anweisung2
      
  
  

• Verzweigung:
     switch (Auswahl-Ausdruck) {
      case Konstante1:
         Anweisung1
         break;
      case Konstante2:
         Anweisung2
         break;
        ...
      default:
         AnweisungN
     }
      
  
  

• Abweisende Schleife:
     while (Bedingung)
       Anweisung
      
  
  

• Nichtabweisende Schleife:
     do
       Anweisung
     while (Bedingung);
      
  
  

• Laufanweisung:
  • sehr allgemeine Syntax:
       for (Initialisierung; Bedingung; Inkrementierung)
         Anweisung         
        
    
    

    Abkürzung für:

       Initialisierung;
       while (Bedingung) {
         Anweisung
         Inkrementierung;
       }  
        
    
    

  • einfache Zählschleife als Spezialfall:
       for (i=0; i<100; i++)
         Anweisung(i)
        
    
    

  • spezielle Anweisungen:
    • break: sofortiges Verlassen der Schleife
    • continue: Beginn des nächsten Schleifendurchgangs (incl. Inkrementierung)

Programmstrukturen:

• Unterprogramme:
  • syntaktisch immer Funktionen
  • spezieller Rückgabewert void
  • Parameterübergabe durch call-by-value
  • call-by-reference mit Zeigern nachbilden

• Gliederungsebenen:
  • Hauptprogramm = spezielle Funktion main
  • Zusammenfassen mehrerer Funktionen in Dateien

• mathematische Standard-Funktionen:
  • die üblichen Grundfunktionen:
    sin, cos, tan, asin, acos, atan, atan2
    sinh, cosh, tanh
    pow, sqrt, exp, log, log10
  • Parameter und Ergebnisse vom Typ double
  • vordefinierte Konstanten für Zahlbereiche und Genauigkeit