Anweisungen(I)

Semantik: Anweisung hat Wirkung (Zustandsänderung), die bei Ausführung eintritt.

abstrakte Syntax:

• einfache Anweisung:
  • Zuweisung
  • Unterprogramm-Aufruf
• zusammengesetzte Anweisung:
  • Nacheinanderausführung (Block)
  • Verzweigung (zweifach: if, mehrfach: switch)
  • Wiederholung (Sprung, Schleife)

Ausführen eines Programms im von-Neumann-Modell:

Was? (Operation) Womit? (Operanden) Wohin? (Resultat) Wie weiter? (nächste Anweisung)

strukturierte Programmierung:

• Nacheinander
• außer der Reihe (Sprung, Unterprogramm, Exception)
• Verzweigung
• Wiederholung

engl. control flow, falsche Übersetzung: Kontrollfluß;

to control = steuern, to check = kontrollieren/prüfen

Folge von (Deklarationen und) Anweisungen

Designfrage: Blöcke

• explizit (Klammern, begin/end)
• implizit (if ...then ...end if)

Designfrage: Deklarationen gestattet

• am Beginn des (Unter-)Programms (Pascal)
• am Beginn des Blocks (C)
• an jeder Stelle des Blocks (C++, Java)

in den meisten Sprachen:

if Bedingung then Anweisung1 
     [ else Anweisung2 ]

Designfragen:

• was ist als Bedingung gestattet (gibt es einen Typ für Wahrheitswerte?)
• dangling else
  • gelöst durch Festlegung (else gehört zu letztem if)
  • vermieden durch Block-Bildung (Perl, Ada)
  • tritt nicht auf, weil man else nie weglassen darf (vgl. ?/:) (Haskell)

switch (e) {
   case c1 : s1 ; 
   case c2 : s2 ;
   [ default : sn; ]
}

Designfragen:

• welche Typen für e?
• welche Werte für ci?
• Wertebereiche?
• was passiert, wenn mehrere Fälle zutreffen?
• was passiert, wenn kein Fall zutrifft (default?)
• (effiziente Kompilation?)

das macht eben in C, C++, Java nicht das, was man denkt:

switch (index) {
  case 1  : odd  ++; 
  case 2  : even ++;
  default : 
     printf ("wrong index %d\n", index);
}

C#: jeder Fall muß mit break (oder goto) enden.

ein switch (mit vielen cases) wird übersetzt in:

• (naiv) eine lineare Folge von binären Verzweigungen (if, elsif)
• (semi-clever) einen balancierter Baum von binären Verzweigungen
• (clever) eine Sprungtabelle

Übung:

• einen langen Switch (1000 Fälle) erzeugen (durch ein Programm!)
• Assembler/Bytecode anschauen

• Fallunterscheidung nach dem Konstruktor
• Bindung von lokalen Namen

abstract class Term   // Scala
case class Constant (value : Int) 
    extends Term
case class Plus (left: Term, right : Term) 
    extends Term
def eval(t: Term): Int = {
  t match {
    case Constant(v) => v
    case Plus(l, r) => eval(l) + eval(r)
  } }