Unit 4: Programmiersprachen

29.01.2013
Programmiertechnik 1 Unit 4: Programmiersprachen Andreas Polze 1 Ablauf Programmiersprachen • 
• 
• 
• 
Spezifika?on, Algorithmen, Programme Formale Beschreibung von Programmiersprachen: EBNF Impera?ve Programmierung: Modula, C Deklara?ve Programmierung –  Funk?onale Programmierung: Scheme –  Logische Programmierung: Prolog •  Objektorien?erte Programmierung: Smalltalk, C++, Objec?ve‐C, Java Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 2 1
29.01.2013
Spezifika?onen •  Eine Spezifika?on ist eine vollständige, detaillierte und unzweideu3ge Problembeschreibung –  vollständig: alle Anforderungen und Rahmenbedingungen sind beschrieben –  detailliert: alle zugelassenen HilfsmiTel (Basisfunk?onalitäten) sind beschrieben –  unzweideu?g: Konformität einer Lösung läßt sich zweifelsfrei feststellen •  Überspezifika3on: Spezifika?on stellt Forderungen auf, die für die Lösung des eigentlichen Problems nicht erfüllt sein müssen •  Unterspezifika3on: Spezifika?on erlaubt Lösungen, die das eigentliche Problem nicht lösen Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 3 Informelle Spezifika?onen •  O\ umgangssprachlich, unpräzise formuliert –  Besser: formale Spezifika?onssprachen: VDM, Z, oder Aussagenlogik –  Spezifika?on stellt auch „nur“ in Abbild der Wirklichkeit dar  Allerdings lässt sich Konformität einer Implemen?erung gegenüber Spezifika?on untersuchen •  Beispiel Rangierproblem: –  „Eine Lokomo?ve in AbschniT B soll die in GleisabschniT A befindlichen Wagen 1, 2, 3 in der Reihenfolge 3, 1, 2 auf GleisabschniT C abstellen“ 1 2 3 A B
Andreas Polze C Unit 4: Programmiersprachen, Programmiertechnik 1 4 2
29.01.2013
Offene Fragen •  Vollständigkeit: –  Wie viele Wagen kann die Lokomo?ve auf einmal ziehen? –  Wie viele Wagen passen auf GleisabschniT B? •  Detailliertheit: –  Welche Ak?onen kann die Lok ausführen? –  Welche Opera?onen sind für Wagen zulässig? –  Lok: Fahren (Vorwärts/Rückwärts), Lok + Wagen: An‐/abkuppeln •  Unzweideu?gkeit: –  Wo soll die Lok am Ende stehen? •  Problemspezifika?on durch Vor‐ und Nachbedingungen –  { P }{ Q }: logische Aussagen, die Zustand vor und nach der Programmausführung beschreiben Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 5 Vorbedingung •  Alle relevanten Eigenscha\en, die vor Beginn der Programmausführung gelten sollen –  Ausgangsposi?on der Fahrzeuge –  Gleisplan, Menge aller Fahrzeuge (Parametertypen) –  Hier: grafische Darstellung 1 2 3 A P=
B
Andreas Polze C Unit 4: Programmiersprachen, Programmiertechnik 1 6 3
29.01.2013
Nachbedingung •  Ende‐Posi?on der Fahrzeuge •  Belegt‐Zustand der GleisabschniTe A Q=
3 B
Andreas Polze 1 2 C Unit 4: Programmiersprachen, Programmiertechnik 1 7 Spezifika?on ggT ( m, n ) •  Für beliebige Zahlen m und n berechne den größten gemeinsamen Teiler ggT(m, n), also die größte Zahl, die sowohl m als auch n teilt –  Vollständigkeit: Was ist der Wertebereich m und n (etwa: nur natürliche Zahlen)? Ist 0 erlaubt? –  Detailliertheit: Welche Opera?onen dürfen verwendet werden (etwa: nur +,‐, oder auch div und mod)? –  Unzweideu?gkeit: Was heißt berechnen? Wie soll das Rechenergebnis zugänglich gemacht werden (etwa: ausdrucken, Rückgabewert einer Funk?on, ...)? Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 8 4
29.01.2013
Vor‐ und Nachbedingungen ggT( m, n ) •  Vorbedingung: –  Programm kann nur mit endlichen, posi?ven Zahlen umgehen –  { m, n ∍ N: 0 < m < 65535 und 0 < n < 65535 } •  Nachbedingung: –  { z = ggt( m, n ), d.h. z ist Teiler von m und n und für alle z‘ die auch m und n teilt, gilt z‘ ≤ z } •  Die Spezifika?on unserer Vorbedingung nimmt Details der avisierten Implemen?erung vorweg: –  Zahlendarstellung: vorzeichenlose 16‐Bit Dualzahlen Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 9 Funk?onale und Nicht‐Funk?onale Eigenscha\en •  Funk?onale Eigenscha\: Welche Forderungen gibt es an den Ergebniswert? –  Beispiel: das Programm soll den ggT ermiTeln •  Nichvunk?onale Eigenscha\: Wie „gut“ soll das Ergebnis ermiTelt werden? –  Beispiel: das Programm soll nicht länger als 6s benö?gen •  Programmiersprachen können i.d.R. nichvunk?onale Eigenscha\en schlecht ausdrücken •  Echtzeitsysteme: –  Korrektheit eines Programms hängt nicht nur von der mathema?schen und logischen Korrektheit des Resultats ab, sondern auch von dem Zeitpunkt, zu dem das Resultat vorliegt Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 10 5
29.01.2013
Algorithmus •  Defini?on: „Ein Algorithmus ist eine detaillierte und explizite Vorschri\ zur schriTweisen Lösung eines Problems.“ •  Beinhaltet im Einzelnen: –  Die Ausführung des Algorithmus erfolgt in einzelnen SchriTen –  Jeder SchriT besteht aus einer einfachen und offensichtlichen Grundak?on –  Zu jedem Zeitpunkt muss klar sein, welcher SchriT als nächster auszuführen ist •  Algorithmus kann von Mensch oder Maschine durchgeführt werden •  Determinis?scher Algorithmus: –  Der jeweils nächste SchriT ist eindeu?g bes?mmt •  Nichtdeterminis?scher Algorithmus: –  An mindestens einer Stelle wird der nächste SchriT zufällig aus einer Menge von möglichen SchriTen ausgewählt Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 11 Beispiel: Schiffe versenken •  Beschreibung: Am Anfang malt man das Spielfeld und es erfolgt das Aufstellen der Schiffe. Danach muss man dann wiederholt nach Gefühl (aber auch mit etwas Glück) schiessen. Der andere antwortet und man muss das Resultat untersuchen. Das geht dann solange bis nach einer gewissen Zeit alle Schiffe gefunden sind. Es gibt ein Ergebnis, und damit ist das Spiel zu Ende. • 
Formalisiert: Anfang Aufstellen wiederholt schiessen Resultat untersuchen solange bis alle Schiffe gefunden Ergebnis Ende. Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 12 6
29.01.2013
Begriffe •  Algorithmus: –  Realisierbare Vorschri\ (Regeln) zur Lösung eines Problems, die in einer endlichen Anzahl von SchriTen zum Ziel führt. •  Programm: –  Formulierung einer Problemlösung, die ein Computer ausführen kann. •  Programmiersprache: –  Für Mensch und Computer verständliche Ausdrucksweise zur Problemlösung, heute meist Kombina?on von (englischen) Worten, mathema?schen Zeichen, Namen und Konstanten –  z.B. Ada, Basic, C, DL/1, Edison, Fortran, ... Plankalkül (Zuse) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 13 Darstellung von Algorithmen •  Natürliche Sprache •  Flussdiagramme –  andere formale und informale graphische Nota?onen –  Vorteil: unmiTelbar verständlich –  Nachteil: für größere Algorithmen schnell unübersichtlich •  Programmiersprachen Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 14 7
29.01.2013
Flussdiagramm – Bsp. ggT( M, N ) ‐ 
‐ 
x  M T
F‐ 
y  N T
‐ 
Anfang Elementarak?on Test; T = true, F = false Ende F
x ≠ y T
F
z  x x > y x  x ‐ y Andreas Polze y  y ‐ x Unit 4: Programmiersprachen, Programmiertechnik 1 15 Zitate • 
Wer nachlässig schreibt, legt dadurch das Bekenntnis ab, dass er selbst seinen Gedanken keinen großen Wert beilegt. Denn nur aus der Überzeugung von der Wahrheit und Wich?gkeit unserer Gedanken entspringt die Begeisterung, welche erfordert ist, um mit unermüdlicher Ausdauer überall auf den deutlichsten, schönsten und krä\igsten Ausdruck bedacht zu sein. (A. Schopenhauer) • 
Die Sprache, in welcher der Student lernt, seine Ideen auszudrücken, hat einen grundlegenden Einfluss darauf, wie er später denkt und Erfindungen macht. (N. Wirth) Die Sprache beeinflusst, wie man denkt, ja sogar, was man denken kann. (N. Wirth) • 
Algol 60 has been a vast improvement on all its successors. (C.A.R. Hoare) It is prac?cally impossible to teach good programming to students that have had a prior exposure to BASIC: as poten?al programmers they are mentally mu?lated beyond hope of regenera?on. (E.W. Dijkstra) The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offense. (E.W. Dijkstra) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 16 8
29.01.2013
Programmiersprachen •  Textuelle Nota?on zur Darstellung von Algorithmen –  Syntak?sche Unterschiede: –  Zuweisung  in C/C++, C#, Java „=“ ; in Pascal, Modula, Oberon „:=“ –  Vergleich ≠ in C „!=„; in Pascal „<>“ •  Algorithmus in C‐ähnlicher Nota?on: ggT( M, N ) {
x = M; y = N;
while (x != y)
if (x > y) x = x-y;
else y = y-x;
z = x;
}
Andreas Polze int ggT( int M, int N ) {
int x = M, y = N;
while (x != y)
if (x > y) x = x-y;
else y = y-x;
return x;
}
Unit 4: Programmiersprachen, Programmiertechnik 1 17 Kontrollstrukturen •  Programm besteht aus –  Elementare Anweisungen –  Zuweisung (variable = wert) –  Ausgaben (print variable) –  Prozedur(auf)rufe (connect(host, port)) ... •  Anweisungen werden in der Reihenfolge des Programmtextes ausgeführt •  Kontrollstrukturen können Abweichungen verursachen –  while (...) ...
– bedingte Schleife –  if(...) ... else ... – bedingte Anweisung –  { ... }
– Anweisungsblock •  Kontrollstrukturen steuern jeweils nur eine Anweisung –  Anweisungen können zu Blöcken zusammengefasst werden –  Anweisungen werden durch Separator getrennt – Semikolon (in C) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 18 9
29.01.2013
Formale Gramma?ken •  Programmiersprachen unterliegen formaler Gramma?k •  üblich: Lexik + Syntax –  Lexikalische Regeln: Was ist Schlüsselwort, was sind Bezeichner, wie schreibt man Kommentare –  Syntaxregeln: Wie gruppiert man einzelne Worte •  Defini?on der Gramma?k o\ durch (E)BNF –  Extended Backus‐Naur‐Form Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 19 Lexikalische Regeln •  Defini?on von „Wörtern“ (Lexem, Token) –  Gruppierung von Zeichen •  Lexikalische Kategorien: Klassen „ähnlicher“ Wörter –  Schlüsselwörter (keywords): Feste Menge reservierter Buchstabenfolgen (z.B. if, while, else) –  Bezeichner: Selbstgewählte Namen für Variablen, Funk?onen, etc. –  C: 1. Zeichen ist Buchstabe oder Unterstrich, gefolgt von beliebig vielen Buchstaben, Ziffern, oder Unterstrich •  Buchstabe: a..z, A..Z; Ziffer: 0..9 –  Einfache oder zusammengesetzte Spezialsymbole: •  + ‐ * / = < > <= >= ; . –  Literale: Zahlenkonstanten, Zeichen(keTen)konstanten •  Lexikalische Mehrdeu?gkeit: Wie weit erstreckt sich ein Lexem? –  "Hallo"+"Welt“ (in Java) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 20 10
29.01.2013
Schlüsselworte in C Andreas Polze auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned con?nue for signed void default goto sizeof vola?le do if sta?c while Unit 4: Programmiersprachen, Programmiertechnik 1 21 Lexikalische Regeln (contd.) •  Trenner zwischen Lexemen: Freiraum und Kommentare –  C: keine Unterscheidung zwischen Leerzeichen, Tabulator, Zeilenumbruch –  Tabulator rückt bis zur nächsten durch 8 teilbaren Spalte ein •  Kommentare in C: Beginnend mit /* ... bis */ –  Innerhalb des Kommentars ist beliebiger Text erlaubt. •  Kein Leerzeichen ist erforderlich, wenn auf einen Bezeichner ein Sonderzeichen folgt –  return sin(3.0) /* Leerzeichen zwischen return, sin */ –  keins zwischen sin, (, zwischen (, 3.0, zwischen 3.0, ) •  Relevanz von Groß‐ und Kleinschreibung: –  C, Java, Python: Unterschied ist relevant, Schlüsselwörter klein –  Pascal, SDL‐92: keine Unterscheidung –  Modula‐2: Unterschied ist relevant, Schlüsselwörter groß Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 22 11
29.01.2013
Lexikalische Regeln (contd.) •  S?l‐Regeln (coding conven?ons): Verwendung von Freiraum, Forma?erung von Kommentaren, ... –  üblich: zusammengehörige Anweisungen werden gleich weit eingerückt (Python: keine Konven?on, sondern durch Syntax verlangt) •  C, Java: wo werden die öffnenden und schließenden Klammern geschrieben? –  üblich: nach Kommas (z.B. in Parameterlisten) wird ein Leerzeichen gesetzt •  Leerzeichen auch vor und nach letztem Argument einer Funk?on, auch vor öffnender Klammer? –  anmelden(vorname, nachname, matrikel) –  anmelden( vorname, nachname, matrikel ) –  anmelden (vorname, nachname, matrikel) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 23 Syntak?sche Regeln •  Allgemein: Sprache ist Menge von Symbolfolgen –  Alphabet A, Sprache L ⊂ A* –  Alphabet: i.d.R. abstrakte Zeichen (Lexeme) •  Hilfssymbole (non‐terminals) und "Zeichen" des Alphabets (Terminalsymbole) •  Defini?on der Sprache mithilfe einer Gramma?k –  verschiedene Gramma?kkalküle, z.B. reguläre Gramma?k, kontexvreie Gramma?k •  Kontexvreie Gramma?k: Hilfssymbole werden unabhängig von ihrem Au\reten im Gesamtprogramm definiert –  Defini?on über Syntaxdiagramm oder EBNF Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 24 12
29.01.2013
Syntaxgraphen •  gerichteter Graph mit genau einem Eingang und genau einem Ausgang –  verschiedene Nota?onen, z.B. Rechtecke für nichTerminale Symbole und Ellipsen für terminale Symbole •  Beispiel: if‐Anweisung in C Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 25 Backus Naur Form (BNF) • 
• 
Metasprache, die Regeln für gül?ge Sätze in einer Sprache angibt Beschreibung der Gramma?k einer Programmiersprache –  Beispiel: <simpleExpr> ::= <term> | <sign><term> | <simpleExpr> <addOp> <term> <addOp> ::= + | ‐ | or <unsigned integer> ::= <digit> | <unsigned integer><digit> –  Wobei: '::=' bedeutet “ist definiert als“ '|' bedeutet "oder“ • 
• 
• 
Terme in spitzen Klammern <term> sind nichTerminale Symbole Alle anderen Symbole sind terminale Symbole ZeichenkeTen werden durch VerkeTen ihrer Beschreibungen dargestellt • 
BNF wurde zuerst im Algol‐60 Report benutzt. –  Letzte Beispiel ist eine rekursive Beschreibung –  (Backus haTe eine frühere Fassung zur Beschreibung von Algol‐58 vorgeschlagen) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 26 13
29.01.2013
Erweiterte Backus Naur Form (EBNF) •  Extended BNF verbessert Lesbarkeit und Genauigkeit von BNF •  Kreuz (Plus +) ‐ ein oder mehrere Elemente –  <unsigned integer> ::= <digit>+ •  Stern (*) – Folge aus Null oder mehr Elementen –  <iden?fier> ::= <leTer><alphanumeric>* •  Geschwei\e Klammern zur Gruppierung von Elementen –  Auf diese Weise können Hilfsregeln eingespart werden –  Wie die für <alphanumeric> –  <iden?fier> ::= <leTer>{<leTer>|<digit>}* •  Eckige Klammern können op?onale Elemente anzeigen –  <integer> ::= [ + | ‐ ]<unsigned integer> –  Kreuz oder Stern können nicht mit eckigen Klammern kombiniert werden •  BNF‐Darstellung ist stets auch eine EBNF‐Darstellung Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 27 EBNF‐Regel Verschiedene Nota?onen •  Hilfssymbole werden mit ::=‐Regeln definiert •  Komposi?on von Regeln: – 
– 
– 
– 
– 
Hintereinanderschreiben von Hilfssymbolen und Terminalsymbolen Alterna?ve Regeln für ein Hilfssymbol: R1 | R2 Op?onale Folge von Symbole: [ S1 S2 ... ] beliebige Wiederholung (auch 0‐mal): ( S1 S2 ... ) * beliebige Wiederholung (wenigstens 1‐mal): ( S1 S2 ... )+ •  Beispiel: Selec?on (if/switch)‐Anweisung in C selec?on_stat Andreas Polze ::= 'if' '(' exp ')' stat | 'if' '(' exp ')' stat 'else' stat | 'switch' '(' exp ')' stat Unit 4: Programmiersprachen, Programmiertechnik 1 28 14
29.01.2013
EBNF Syntaxgraphen • 
Syntaxgraphen korrespondieren wesentlich intui?ver zu Regeln, wenn man sich auf Schreibweisen für Wiederholungen und standardisierte Graphen einigt one alt
some
two body some ::= body+ ;
alt ::= ( one | two ) ;
many
opt
body body many ::= body* ;
opt ::= [ body ] ;
• 
Analog zu den Syntaxgraphen sehen arithme?sche Ausdrücke dann etwa so aus: sum ::= product ( ('+'|'‐') product )*; product ::= term ( ('*'|‘/') term )*; term ::= ( Number | '(' sum ')' ) ; • 
EBNF benö?gt keine leeren Alterna?ven (anders als BNF) Andreas Polze Unit 5: Werkzeuge und Technologien, Programmiertechnik 1 29 BNF für C – ein AusschniT stat ::= labeled_stat | exp_stat | compound_stat | selec?on_stat | itera?on_stat | jump_stat; labeled_stat::= id ':' stat | 'case' const_exp ':' stat | 'default' ':' stat; exp_stat::= exp ';‘ | ';'; compound_stat::= '{' decl_list stat_list '}‘ | '{'stat_list '}‘ | '{' decl_list'}‘ | '{''}'; stat_list::= stat | stat_list stat; selec?on_stat::= 'if' '(' exp ')' stat | 'if' '(' exp ')' stat 'else' stat | 'switch' '(' exp ')' stat; Andreas Polze itera?on_stat::= 'while' '(' exp ')' stat | 'do' stat 'while' '(' exp ')' ';‘ | 'for' '(' exp ';' exp ';' exp ')' stat | 'for' '(' exp ';' exp ';'')' stat | 'for' '(' exp ';'';' exp ')' stat | 'for' '(' exp ';'';'')' stat | 'for' '('';' exp ';' exp ')' stat | 'for' '('';' exp ';'')' stat | 'for' '('';'';' exp ')' stat | 'for' '('';'';'')' stat ; Unit 4: Programmiersprachen, Programmiertechnik 1 30 15
29.01.2013
Mehrdeu?gkeit von Gramma?ken •  u.U. mehrere Möglichkeiten, eine Anweisung mit der Gramma?k in Übereins?mmung zu bringen (zu parsen) •  Beispiel: if‐Anweisung in C, Java, ... –  if_stmt ::= “if“ "("condi?on “)“ statement [“else“ statement ] –  statement ::= simple_stmt | while_stmt | if_stmt | ... •  Was bedeutet dann –  if (x >= y) if (x > y) a=x; else b=y; •  Auflösung der Mehrdeu?gkeit: z.B. durch zusätzliche (natürlichsprachige) Regeln –  Beispiel: „Der else‐Zweig gehört stets zum letztmöglichen if‐Teil“ Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 31 (Sta?sche) Seman?sche Regeln •  Nicht alle Sätze der Sprache L sind „sinnvoll“ –  Programmiersprache ist nicht kontexvrei –  Versuche, alle Regeln für korrekte Programme in Gramma?k zu erfassen, sind in der Vergangenheit meist gescheitert (Ausnahme: z.B. Algol‐68) •  Zusätzlich zur Gramma?kdefini?on weitere Regeln –  Einhaltung aller Regeln: Wohlgeformtheit (well‐formedness) •  Verletzung von Wohlgeformtheit: ill‐formed (fälschlich o\: illegal) –  z.B. C, C++, Java: Variablen müssen vor Verwendung deklariert sein –  Java, Python: lokale Variablen müssen vor Verwendung einen Wert erhalten haben •  Regeln o\ in natürlicher Sprache formuliert –  u.U. auch mit mathema?schen Formalismen, z.B. Prädikatenkalkül Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 32 16
29.01.2013
(Dynamische) Seman?sche Regeln •  Ist ein Programm wohlgeformt: was „bedeutet“ das Programm? –  Antwort durch dynamische Seman?k •  Funk?onale Sicht: Programm ist eine mathema?sche Funk?on; Seman?k beschreibt Parameter und Ergebnis –  Begriff der berechenbaren Funk?on •  Opera?onale Sicht: Programm ist Folge von Ak?onen –  Trace‐Seman?k: Bedeutung eines Programms ist die Menge der möglichen Traces –  Begriff der beobachtbaren Ak?on: Ein/Ausgabe, Schreiben auf „wich?ge“ Variablen (C: Variablen, die als vola?le deklariert sind) •  as‐if rule: zwei Programme sind gleich, wenn sie bei gleicher Eingabe die gleiche Folge beobachtbarer Ak?onen erzeugen •  Gleichheit von Programmen im Allgemeinen nicht entscheidbar –  (Halteproblem) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 33 Implemen?erung von Spezifika?onen •  Spezifika?on: beschreibt Problem –  Algorithmus: löst ein Problem –  einfachster Fall einer Spezifika?on S: Vorbedingung P, Nachbedingung Q •  Algorithmus A löst das Problem S, wenn A, angewendet auf Eingabe mit Vorbedingung P, eine Ausgabe produziert, die Q erfüllt –  A „implemen?ert“ S –  A „löst“ S •  nicht jede Spezifika?on hat eine Lösung –  wenn es eine Lösung gibt, gibt es i.d.R. beliebig viele Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 34 17
29.01.2013
Terminierung •  häufige Forderung an Algorithmus: er soll letztlich terminieren (also: beendet sein) –  Ausnahmen: interak?ve Programme, die prinzipiell beliebig lange laufen (Textverarbeitung, Computerspiel) •  Wird Algorithmus stets terminieren (unabhängig von der Eingabe)? –  o\ schwierig zu beantworten, weil Algorithmus Schleifen enthält –  im Allgemeinen unentscheidbar (Halteproblem) •  Alan Turing, 1936 (bewiesen für Turingmaschinen) –  Das Halteproblem beschreibt die Frage, ob die Ausführung eines Algorithmus zu einem Ende gelangt. Alan Turing hat bewiesen, dass es keinen Algorithmus gibt, der diese Frage für alle möglichen Algorithmen und beliebige Eingaben beantwortet. Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 35 Ulam‐Problem •  Nach Stanisław Marcin Ulam –  Beginne mit einer beliebigen Zahl n. Ist sie ungerade, mul?pliziere sie mit 3 und addiere 1, ansonsten halbiere sie. –  Fahre so fort, bis 1 erreicht ist. while n >
if n %
n =
else:
n =
1:
2 == 1:
3*n+1
n/2
–  Die Frage, ob dieser Algorithmus für jede Anfangszahl terminiert, ist bislang ungelöst –  In einer Spezifika?on { P } A { Q } gehen wir immer von Terminierung von A aus –  Terminiert A nicht, so erfüllt er jede Nachbedingung Q (da er sie nicht verletzt) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 36 18
29.01.2013
Vom Algorithmus zum Programm •  Algorithmus zunächst informal gegeben –  o\ „im Kopf“ •  Formalisierung als Programm –  Festlegen von Parametern des Algorithmus –  Parameter für Prozeduren, evtl. Kommandozeilenparameter •  Werte für Parameter evtl. auch in Programm kodiert –  Einhalten der Programmsyntax (z.B. „Programmkopf“) –  Au\eilen des Programms auf Übersetzungseinheiten (Module, Klassen, Pakete •  Deklara?on und Ini?alisierung von Variablen •  Eingabe des Programms als reinen Text in Datei –  üblich: Dateiendung deklariert die Programmiersprache –  C Programme: prog.c, C++: prog.c++, prog.cpp Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 37 Übersetzen des Programms •  Compiler überführt Programm in interne Zwischenrepräsenta?on –  Überprüfen der Syntax entsprechend der Gramma?k der Programmiersprache –  Variablen  Alloka?on von Speicherplatz –  Funk?onen  Codesegmente, EintriTspunkte in das Programm •  Aus Zwischenrepräsenta?on wird Maschinencode generiert –  Objektmodul •  Linker bindet Objektmodule zu Programmen –  Spezialfall: Programm aus nur einem Modul –  Üblicherweise werden Bibliotheksfunk?onen an Objektmodul „gebunden“ •  Jedes C Programm beginnt mit einer Hauptrou?ne –  int main( int argc, char * argv [] )
–  Java: public static void main(String [] args)
•  Körper der Haupvunk?on ist ein Anweisungsblock  unser Algorithmus Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 38 19
29.01.2013
Compiler •  Lexikalische Analyse: Zerlegen des Programmtextes in Wörter (frontend) –  Leerzeichen, Zeilenumbrüche werden envernt –  Es entsteht eine Folge von Token •  Syntaxanalyse: entspricht Programm den Regeln der Sprache? (frontend) –  Stellt eine gegebene Tokenfolge einen Satz unserer Sprache dar? –  Analsye mit Hilfe eines endlichen Automaten –  Bsp: reguläre Ausdrücke: ((a + b) * c ‐ d) / 17 •  Klammern? Vorrangregeln? •  Gramma?sche Ak?onen –  Variablen in Tabellen verwalten –  Überprüfen, ob alle verwendeten Variablen deklariert sind –  Funk?onsaufrufe, Sichtbarkeitsregeln •  Codegenerierung (backend) Load a Load b Add Load c Mul Load 17 Div Code zur Berechnung
unseres Ausdrucks auf
einer Stackmaschine
–  Zwischencode (P‐Code, Java Bytecode, .NET MSIL) vs. Maschinencode –  Mitunter wird Assembler‐Code generiert; Assembler erzeugt Maschinencode Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 39 Assembler‐Beispiel int ggT( int M, int N ) {
int x = M, y = N;
while (x != y)
if (x > y) x = x-y;
else y = y-x;
return x;
} ggt.c
gcc –S ggt.c auf Intel x86
.text
.globl _ggT
_ggT:
pushl %ebp
movl
%esp, %ebp
subl
$24, %esp
movl
8(%ebp), %eax
movl
%eax, -16(%ebp)
movl
12(%ebp), %eax
movl
%eax, -12(%ebp)
jmp
L8
Andreas Polze L3:
movl
cmpl
jle
movl
leal
subl
jmp
-16(%ebp), %eax
-12(%ebp), %eax
L4
-12(%ebp), %edx
-16(%ebp), %eax
%edx, (%eax)
L2
movl
leal
subl
-16(%ebp), %edx
-12(%ebp), %eax
%edx, (%eax)
L4:
ggt.s
L2:
L8:
movl -16(%ebp), %eax
cmpl -12(%ebp), %eax
jne
L3
movl -16(%ebp), %eax
leave
ret
.subsections_via_symbols
Unit 4: Programmiersprachen, Programmiertechnik 1 40 20
29.01.2013
Babylonische Sprachvielfalt (1. Mose, Kap 11)
•  m Programmiersprachen, n Rechnerarchitekturen = m * n Compiler? FORTRAN S/360 Algol PDP‐11 VAX Pascal Alpha Simula Intel x86 Smalltalk MC 680x0 C/C++ MIPS Java Prolog Basic Lisp Scheme Andreas Polze Problem:
•  Nur C auf wirklich
allen Plattformen
unterstützt
...
POWER SPARC HP PA/RISC Itanium ARM Unit 4: Programmiersprachen, Programmiertechnik 1 41 Einheitliche interne Zwischenrepräsenta?on • 
gcc – GNU Compiler Collec?on, n frontends, m backends FORTRAN S/360 Algol PDP‐11 Pascal Simula gcc Zwischen‐
repräsenta?on MC 680x0 C/C++ MIPS Java Basic Lisp Scheme Andreas Polze Alpha Intel x86 Smalltalk Prolog VAX Problem:
•  Aufrufkonventionen
•  Datenrepräsentationen
•  Little vs. Big Endian
•  Laufzeitsysteme der
Programmiersprachen
POWER SPARC HP PA/RISC Itanium ARM Unit 4: Programmiersprachen, Programmiertechnik 1 42 21
29.01.2013
Virtuelle Maschinen •  P‐Code, Smalltalk, Java, .NET FORTRAN S/360 Algol PDP‐11 Pascal Simula Virtuelle Maschine MC 680x0 C/C++ Prolog Basic Lisp Scheme Andreas Polze Alpha Intel x86 Smalltalk Java VAX MIPS Problem:
•  VM häufig nur für eine
Programmiersprache
•  Performance
•  Nur .NET hat ein sprachübergreifendes Typsystem
•  Nur Java unterstützt (fast)
alle Zielplattformen
POWER SPARC HP PA/RISC Itanium ARM Unit 4: Programmiersprachen, Programmiertechnik 1 43 Interpreter •  Compiler –  Übersetzt kompleTen Programmtext bevor erste Anweisung ausgeführt wird –  Typisch für Pascal, Modula, COBOL, Fortran, C, C++, Ada •  Interpreter –  übersetzt jede Anweisung separat und kann sie sofort ausführen –  Typisch für BASIC, APL, Lisp, Prolog •  MiTelweg –  Compiler übersetzt in maschinenunabhängigen Bytecode –  Bytecode wird interpre?ert oder „just‐in‐?me“ dynamisch kompiliert –  Java, Smalltalk, .NET‐Sprachen Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 44 22
29.01.2013
Linker/Loader Quellprogramm
•  Quellprogramm verwendet symbolische Adressen (Variablen) •  Compiler bindet symbolische Adressen an verschiebbare Adressen •  Linkeditor/Lader bindet verschiebbare Adressen an absolute Adressen Diese Bindung kann beim Programmstart (dynamisch) oder beim Übersetzen/Linken (sta?sch) geschehen Andreas Polze Andere
Objektmodule
Compiler oder
Assembler
Compilezeit
Objektmodul
Systembibliotheken
Linkeditor
Ladezeit
Lademodul
Dynamisch
geladene
Systembibliotheken
Lader
Image im
Speicher
(Prozess)
Unit 4: Programmiersprachen, Programmiertechnik 1 Ausführungszeit
(runtime)
45 Laufzeitsystem •  Verwaltung von Speicher zur Laufzeit –  Stack für Prozeduraufrufe –  Heap für dynamische Datenstrukturen –  Unter Umständen: garbage collec?on •  Implemen?eren von Ein‐ und Ausgabe –  stdin / stdout / stderr – Filedeskriptoren 0, 1, 2 nach UNIX‐Konven?on •  Laden externer Bibliotheken –  Einsprungtabellen für expor?erte Funk?onen Stack Heap Text Sta?sche Daten Klassisches Speicherlayout
für einen UNIX Prozess
•  SchniTstelle zum Betriebssystem Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 46 23
29.01.2013
Ein‐ und Ausgabe •  „interessante“ Programme konsumieren Eingaben des Nutzers und produzieren Ausgaben •  Textuelle SchniTstellen (CUI – command‐line user interface) –  Eingaben in Terminal über Tastatur, Ausgaben auf Terminal •  Grafische SchniTstelle (GUI – graphical user interface) –  Eingabe über Maus und Tastatur •  Flexible Eingabeelemente (Menüs, Schalvlächen, Texvelder) –  Ausgabe als Rastergrafik •  Flexible Verwendung von Schri\ und grafischen Darstellungen •  Ein‐ und Ausgabe wird durch Funk?onen in Systembibliotheken realisiert Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 47 Portabilität •  Ziel: Das gleiche Programm soll auf verschiedener Hardware, verschiedenen Betriebssystemen gleichar?g funk?onieren •  Compiler‐Lösung: Compiler für wohldefinierte (normierte) Sprachen –  Zur Por?erung auf ein neues System muss der Quelltext verfügbar sein •  VM‐Lösung: Interpreter/Just‐In‐Time‐Compiler für Zielpla‰orm –  Zur Por?erung genügt u.U. der Bytecode •  Java: „write once, run anywhere“ Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 48 24
29.01.2013
Programmierfehler • 
• 
Eingabe des Programms in Texteditor Übergabe des Programms an Compiler/Interpreter –  Analyse durch Compiler zeigt Verletzung der Sprachsyntax an • 
Syntaxfehler –  z.B. Schreibfehler in Schlüsselwörtern –  Analyse zeigt u.U. auch Verletzung von Benutzungsregeln an • 
• 
Seman?kfehler Beispiel: Verletzung des Typsystems (Typfehler) • 
Bei Ausführung wird das Programm u.U. aufgrund von Fehlern abgebrochen • 
Selbst bei Beendigung ohne Fehler ist u.U. das Ergebnis nicht das erwartete –  z.B. Verknüpfung von Strings und Zahlen in einer Addi?onsopera?on –  Laufzeivehler –  Denkfehler Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 49 Programmierfehler (contd.) •  Fehler im Programm heißen auf Englisch bugs –  Erste Röhrenrechner: Eindringen von Insekten in den Rechnerraum war Hauptursache für den Ausfall von Röhren •  Envernen von Fehlern: Debugging •  Entwicklungszyklus: Edi?eren, Kompilieren, Testen •  E. Dijkstra (1970): Program tes?ng can be used to show the presence of bugs, but never to show their absence! Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 50 25
29.01.2013
Programmierumgebungen •  Ziel: Verkürzung des Entwicklungszyklus •  Strategien: –  Interpreter: interak?ver Modus (z.B. Python) –  Compiler: Integra?on von Quelltexteditor, Compiler (build process), Debugger, evtl. Quelltextverwaltungssystem, ... •  IDE (Integrated Development Environment) – 
– 
– 
– 
Editor: Vereinfachung der Eingabe von Programmen automa?sche Vervollständigung Syntax‐Hervorhebung (highligh?ng) Generierung von Codeblöcken (wizards) •  Beispiele: –  Java: Eclipse, netbeans, JBuilder, BlueJ –  C, C++: Visual Studio, C++Builder –  Python: IDLE, PythonWin Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 51 Programmentwurf: Datenstrukturen •  Daten sind Objekte mit denen ein Programm umgehen soll. –  Wahrheitswerte, Zahlen, Geburtstage, Texte, Bilder, Musik, Videos –  Typen, Speicherplatz, Opera?onen •  Abstrakter Datentyp (Datenstruktur) –  Menge gleichar?ger Daten + Sammlung von Opera?onen + Gleichungen –  Opera?onen: ordnet einer festen Zahl von Eingabedaten ein Ergebnis zu –  Gleichungen: beschreiben Seman?k der Opera?onen •  Stelligkeit von Opera?onen –  Addi?on „+“ : ordnet zwei Eingabewerten einen Ausgabewert zu –  Addi?on ist zweistellig – ebenso wie bereits betrachtete Opera?on ggT() –  Eingebaute vs. Programm‐definierte Opera?onen •  Opera?on: –  Abbildung f: τ1 x τ2 x ... x τn  σ –  Ordnet ArgumenTupel (a1, a2, ..., an) mit ai ∈ τi Ergebnis f(a1, a2, ..., an) ∈ σ zu Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 52 26
29.01.2013
Opera?onen •  Spezialformen für arithme?sche und boolesche Opera?onen –  Zweistellig: +, ‐, *, /, div, mod, or, and, xor – Infix‐Nota?on –  Einstellige Opera?onszeichen: sin 45, ‐12, not x – Präfix‐Nota?on •  Präzedenzen, Regeln zur Klammersetzung •  Vorrangregeln (in absteigender Reihenfolge) – 
– 
– 
– 
Einstellige Opera?onen: not (!),... Mul?plika?ve Opera?onen: *, div (/), mod (%), and (&),... Addi?ve Opera?onen: +, ‐, or (|),... Vergleichende Opera?onen: = (==), ≠ (!=), <, ≤ (<=), >, ≥ (>=) •  Ausdrücke mit Operatoren gleicher Präzedenz: linksgeklammert –  x / y * z + u % v entspricht: –  (( x / y ) * z ) + ( u % v ) •  Seman?k der Opera?onen durch Gleichungen beschrieben Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 53 Boolesche Werte • 
Einfachster Datentyp (boolean) –  Werte: true und false –  Verknüpfungen: or, and, not –  or: Boolean x Boolean  Boolean, not: Boolean  Boolean • 
Seman?k der Opera?onen: –  Beschreibung durch Wahrheitswertetabellen –  Gleichungen (für Typen mit großem Wertebereich die einzige Op?on) •  Erweiterung: x xor y = (x and not y) or (not x and y) • 
C hat keinen Typ Boolean – benutzen int –  Aufzählungstyp: enum boolean { false = 0, true = 1 } –  Präprozessor‐Defini?onen: •  #define true 1 •  #define false 0 • 
Verkürzte Auswertung: –  if (x > 0 && y > 0 && ggT(x,y) == 1) ... Andreas Polze Datentyp: boolean (Bool) Werte: true, false Opera?onen: or, and: Bool x Bool  Bool not: Bool  Bool true, false:  Bool Gleichungen: ∀x, y ∈ Bool: true or x = true, true and x = x false or x = x, false and x = false not true = false, not false = true Unit 4: Programmiersprachen, Programmiertechnik 1 54 27
29.01.2013
Ganze Zahlen in C Integrale Typen: char, short, int, long, long long –  sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long) • 
int –  Ganze Zahlen –  Wertebereich durch Prozessorarchitektur bes?mmt (üblich: 32 bit) –  Literale (Werte im Quelltext): Dezimal (117), Oktal (führende 0, 067), Hexadezimal (führendes 0x, 0x20AC) –  Opera?onen nach int: +, ‐ (unär und binär), *, /, %, **, <<, >> –  Opera?onen nach bool (int mit Wertebereich 0, 1): ==, !=, <, <=, >, >= • 
long – 
– 
– 
– 
• 
Ganze Zahlen Wertebereich: sizeof(int) <= sizeof(long) – üblich: 64 bit Literale enden mit l oder L (z.B. 1000000000000L) int‐Opera?onen, die den Wertebereich von int verlassen, liefern int % 2#bits unsigned char, unsigned int, unsigned long –  Datentyp für natürliche Zahlen Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 55 Rich?ge Datenstrukturen wählen •  Verbessern ggT()‐Algorithmus –  Verwenden %‐Opera?on anstelle schriTweiser Subtrak?on int ggT( int M, int N) { int x = M, y = N; while ((x > 0) && (y > 0)) if ( x >= y) x = x % y; else y = y % x; z = x+y; } Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 56 28
29.01.2013
Reelle Zahlen in C float, double •  Gleitkommazahlen –  üblicherweise repräsen?ert durch 32‐bit (float) oder 64‐bit (double) IEEE‐754 –  Literale: z.B. 3.1415, 113e‐4 •  allgemeiner: –  floa?ng‐point‐constant: frac?onal‐constant exponent‐part opt floa?ng‐suffix opt | digit‐sequence exponent‐part floa?ng‐suffix opt –  frac?onal‐constant: digit‐sequence opt . digit‐sequence | digit‐sequence . –  exponent‐part: e sign opt digit‐sequence | E sign opt digit‐sequence –  sign : one of + – –  digit‐sequence: digit | digit‐sequence digit –  floa?ng‐suffix : one of f l F L –  Opera?onen wie int (außer <<, >>) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 57 Operatorüberladung •  arithme?sche Operatoren arbeiten auf verschiedenen Typen •  Ergebnistyp hängt von Operandentypen ab –  int + int  int –  long + long  long –  float + float  float •  Typanpassung bei gemischten Opera?onen –  „speziellerer“ Typ (Teilmenge) wird in allgemeineren Typ (Obermenge) umgewandelt –  Beispiel: int + float  float Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 58 29
29.01.2013
Typkonver?erung •  Werden Integer und Float‐Zahlen in arithme?schen Ausdrücken verknüp\, so finden Konver?erungen staT – 
– 
– 
– 
– 
1ter Operand long double – 2ter Operand wird konver?ert zu long double Sonst: 1ter Operand double – 2ter Operand wird konver?ert zu double Sonst: 1ter Operand float – 2ter Operand wird konver?ert zu float Sonst: konver?ere char und short zu int Dann: wenn einer der Operanden long – konver?ere anderen Operand zu long •  „niedrigerer Typ“ wird in „höheren Typ“ umgewandelt –  float (32‐bit Gleitkomma) wird nicht automa?sch in double konver?ert –  Regeln komplexer wenn unsigned‐Typen involviert •  Konver?erungen auch bei Zuweisungen –  Wert auf rechter Seite wird in ResultaTyp links konver?ert •  Cast – explizite, erzwungene Konver?erung –  Ergebnistyp in Klammern angeben (double), (int), (void *) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 59 Konver?erung ‐ Beispiele • 
int i; char c; i = c; /* ok */ c = i; /* modulo 28 */ • 
float x; int i; x = i; /* ok, Konver?erung */ i = x; /* Abschneiden der Nachkommastellen */ • 
double x; float y; x = y; /* ok, Konver?erung */ y = x; /* Abschneiden oder Runden, Implementa?onsabhängig */ • 
double sqrt(double) – aus <math.h> sqrt((double) n); /* explizite Typkonver?erung (cast) */ sqrt( 2 ) == sqrt( 2.0 ); /* implizite Konver?erung int  double */ Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 60 30
29.01.2013
Typkonver?erung •  Einfache Datentypen und ihre Opera?onen in C +, -, *, /,
sin, log, sqrt
float double +, -, *, /, %
Reelle Zahlen Cast char short int long Ganze Zahlen Long long Vergleichsoperationen
==, !=, <=, <, >=, >
Int (boolean) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 61 Typecast ‐ Anwendung •  Portabler Zufallszahlengenerator aus Standard‐Bibliothek static unsigned long int next = 1;
/* rand: Zufallszahl von 0..32767 */
int rand( void ) {
next = next * 1103515245 + 12345;
return (unsigned int) (next/65536) % 32768;
}
/* srand: Ausgangswert (seed) für rand() einstellen */
void srand(unsigned int seed) {
next = seed;
}
Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 62 31
29.01.2013
ZeichenkeTen in C •  ZeichenkeTen werden durch Verweis auf erstes Zeichen dargestellt –  char string1[] = ”Guten Tag”; –  char * string2 = ”Auf Wiedersehen”; •  Ende einer ZeichenkeTe wird durch ein Null‐Byte angezeigt –  Länge einer ZeichenkeTe: Null‐Byte (`\0`) zählt nicht. –  strlen( string1 ) == 9; •  char  Repräsenta?on eines Bytes, UTF‐8 •  wchar_t  Repräsenta?on eines „wide Characters“, UTF‐16 (Unicode) – 
– 
– 
– 
Unicode‐Unterstützung in C ist Compiler‐abhängig wchar_t foo[512] = L"φωωβαρ"; Unicode‐Literale können auch als Hex‐Werte angegeben werden Beispiele: UTF‐8 ‐ \x2F, UTF‐16 ‐ \x3FA1 •  Falle: –  string1 = string2; /* hier wird nur Zeiger umgesetzt, keine Kopie! */ Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 63 Opera?onen auf ZeichenkeTen • 
Definiert in <string.h>; Teil der Standard-C-Bibliothek libc.a
Länge eines Strings: int strlen(const char* str) Kopieren eines Strings; Heap – Freigeben! char* strdup(const char* str) Vergleich zweier Strings: int strcmp(const char* str1,const char* str2) int strncmp(const char* str1,const char* str2,size_t num) Zeichen finden (von vorne / von hinten) char* strchr(const char* str,int c) char* strrchr(const char* str,int c) Kopieren eines Strings char* strcpy(char* dest,const char* src) char* strncpy(char* dest,const char* src,size_t num) VerkeTen zweier Strings: char* strcat(char* dest,const char* src) char* strncat(char* dest,const char* src,size_t num) Andreas Polze Teilstring suchen char* strstr(const char* str,const char* substr) Vorkommen von Zeichen zählen size_t strspn(const char* str,const char* accept) Abwesenheit von Zeichen zählen size_t strcspn(const char* str,const char* reject) Unit 4: Programmiersprachen, Programmiertechnik 1 64 32
29.01.2013
Sonderzeichen in Strings •  Anführungszeichen selbst als Teil des Strings? –  Lösung: Spezialsyntax: \" (Zeichen nach Backslash gilt nicht als Stringende) •  Escape‐Sequenzen •  Weitere Sonderzeichen: – 
– 
– 
– 
– 
– 
\n: Zeilenende \t: Tabulator \0: Nullbyte \xHH: Hexadezimal‐no?ertes Byte (z.B. \xF6) \\: der Backslash selbst ... Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 65 Impera?ve Programmierung •  Variablen in Programmiersprachen: Bindungen zwischen Namen und Wert –  historisch: benannte Speicherplätze (Speicheradressen) –  Variablenbelegung •  Typ einer Variablen: Beschränkung des Wertebereichs einer Variablen (Menge der möglichen Belegungen) –  aus Variablentyp ergibt sich o\ Zahl der benö?gten Bytes sowie –  Interpreta?on der Speicherinhalts •  Variablen sind typisiert (Festlegung des zu verwendenden Speicherplatzes) –  Compiler generiert Typkonver?erungen bei Zuweisungen (Konstanten‐) –  Zuweisung: Änderung der Bindung zwischen Variable und Wert •  Impera?ve Sprachen: Bedeutung des Programms entsteht durch Folge von Zuweisungen und Ein‐/Ausgabeopera?onen –  Programmierer gibt genau an, welche SchriTe in welcher Reihenfolge abgearbeitet werden sollen (sequen?ell) –  Beispiele: C, Pascal, Modula‐2, Algol, Fortran Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 66 33
29.01.2013
Zuweisung in C •  Elementare Zuweisung: <variable> = <wert> –  x = 5 •  Mehrfachzuweisung: <variable> = <variable> = ... = <wert> –  a = b = c = 0.0 •  Kombina?on von arithme?schem Operator und Zuweisung – 
– 
– 
– 
– 
<variable> <op>= <wert> bedeutet (i.d.R.) <variable> = <variable> <op> <wert> x += 3 y *= 2 a /= b •  Weitere Formen von <variable> später –  x[4] = y –  person.alter += 1 Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 67 Kontrollstrukturen •  Steuern Ablauf des Programmes •  3 Kontrollstrukturen genügen für beliebige Algorithmen: –  sequen?elle Komposi?on –  Alterna?vanweisung –  while‐Schleife •  "genügen für beliebige Algorithmen": Turing‐vollständig –  Church‐Turing‐These: Die Klasse der Turing‐berechenbaren Funk?onen ist genau die Klasse der intui?v berechenbaren Funk?onen. Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 68 34
29.01.2013
Sequen?elle Komposi?on •  C, Pascal: A1; A2; A3; ...; An •  Seman?k der sequen?ellen Komposi?on: –  A1...An werden hintereinander ausgeführt –  es sei denn, eine Ausnahme triT miTendrin auf •  Beispielspezifika?on: –  Gib Wechselgeld für einen Betrag zwischen 0 und 100 Euro. –  Es stehen jeweils genügend Münzen im Wert von 1, 2, 5, 10, 50 Cent und 1 € zur Verfügung. –  Ziel ist es, mit möglichst wenig Münzen auszukommen. Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 69 Beispiellösung sequen?ell int rest, Betrag;
rest
k6 =
rest
k5 =
rest
k4 =
rest
k3 =
rest
k2 =
k1 =
= Betrag; rest / 100;
= rest % 100; rest / 50;
= rest % 50; rest / 10;
= rest % 10; rest / 5;
= rest % 5; rest / 2;
rest % 2;
Andreas Polze # Zahl der Euro-Münzen # Zahl der 50-Cent-Stücke # Zahl der 10-Cent-Stücke # Zahl der 5-Cent-Stücke # Zahl der 2-Cent-Stücke # Zahl der 1-Cent-Stücke Unit 4: Programmiersprachen, Programmiertechnik 1 70 35
29.01.2013
Verkürzte Nota?on int rest, Betrag;
rest
k6 =
rest
k5 =
rest
k4 =
rest
k3 =
rest
k2 =
k1 =
= Betrag; rest / 100;
%= 100; rest / 50;
%= 50; rest / 10;
%= 10; rest / 5;
%= 5; rest / 2;
rest % 2;
Andreas Polze # Zahl der Euro-Münzen # Zahl der 50-Cent-Stücke # Zahl der 10-Cent-Stücke # Zahl der 5-Cent-Stücke # Zahl der 2-Cent-Stücke # Zahl der 1-Cent-Stücke Unit 4: Programmiersprachen, Programmiertechnik 1 71 Alterna?vanweisung •  Auswahl zwischen zwei Anweisungen A1 und A2, in Abhängigkeit von Bedingung B –  C Syntax: if ( B ) A1; else A2; –  A1 und A2 können Blöcke sein ( {} ) •  Seman?k der Alterna?vanweisung: –  Zuerst wird B ausgewertet. Ist das Ergebnis wahr, wird A1 ausgeführt, sonst A2 •  C: falsch ist 0 –  enum boolean { false, true }; false == 0; –  Wahr ist jeder Wert != 0 Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 72 36
29.01.2013
Verschachtelte Alterna?ven if ( B1 ) if ( B2 ) if ( B3 ) A1; else A2; else if ( B4 ) A3; else A4; else A5; •  Einrückungen verbessern Lesbarkeit ! Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 73 Die while‐Schleife •  while ( B ) A; •  Seman?k der while‐Schleife: –  1.Werte B aus –  2.Falls B erfüllt ist, führe A aus und setze dann mit 1. fort –  3.(Anderenfalls ist die while‐Schleife beendet) •  Erweiterungen der while‐Schleife in C: –  break‐Anweisung (Abbruch der Schleife) –  con?nue‐Anweisung (Sofor?ges Fortsetzen mit SchriT 1) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 74 37
29.01.2013
while‐Schleife – ein Beispiel •  Beispiel: Berechnung der Fakultät int faculty( int n ) { int iter = 1; int fact = 1; while (iter < n) { fact *= iter; iter++; } return fact; } Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 75 Welche Programmiersprache? •  Computer führt Berechnungen auf determinis?sche Weise aus –  bei gleicher Eingabe und gleichem inneren Zustand erzeugt er gleiche Ausgabe •  Art und Weise der Berechnung wird durch ein Programm festgelegt –  formale Sprachen: Nota?on des Programms folgt festen Regeln, jedes Programm hat mathema?sch klare Bedeutung •  Historisch: Formulierung mit Hilfe von Opera?onen der Hardware –  Maschinensprache, Assembler •  Heute: Abstrak?on mithilfe höherer Programmiersprachen –  Impera?ve Programmierung: Anweisungen an den Computer –  Funk?onale Programmierung: Ziel der Berechnung wird durch mathema?sche Funk?on beschrieben •  Defini?on der Funk?on mithilfe vorhandener Funk?onen –  Deklara?ve Programmierung: Eigenscha\en der gesuchten Lösung werden definiert •  konkreter Algorithmus zur Lösung wird nicht vorgegeben Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 76 38
29.01.2013
Impera?ve Programmiersprachen • 
• 
• 
• 
• 
• 
• 
• 
• 
• 
• 
FORTRAN Algol PL/1 BASIC Pascal C C++ Java Python ... Impera?ve Sprachen beinhalten o\ funk?onale oder deklara?ve Elemente –  Rekursion –  z.B. Funk?onen höherer Ordnung Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 77 FORTRAN •  Formula Translator •  in den 1950ern entwickelt, unter Leitung von John W. Backus –  für IBM 704 (36‐bit‐Worte, erster Rechner mit Gleitkommahardware) –  erste Hochsprache (neben LISP) •  ursprünglich: Orien?erung auf Lochkartenprogrammierung –  Jede Lochkarte enthält eine Zeile –  Spalten 1..5 enthalten die Zeilennummer, Spalten 7..72 Programmtext –  Kontrollflußanweisung: GOTO •  neuere Versionen bereinigen und vereinfachen die Syntax –  GOD is REAL (unless declared INTEGER) •  Sprachversionen: FORTRAN II (1958), FORTRAN IV (1961), FORTRAN 66, FORTRAN 77, Fortran 90, Fortran 95, Fortran 2003 Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 78 39
29.01.2013
Pascal •  zwischen 1968 und 1974 von Prof. Niklaus Wirth, ETH Zürich, entwickelt –  für Unterrichtszwecke •  strukturierte Programmierung, Rekursionen, Unterprogramme •  später um weitere Konzepte erweitert –  Turbo‐Pascal: Modularisierung (units) –  Object‐Pascal, Delphi: Objekt‐Orien?erung •  ISO/IEC 7185:1983, ISO/IEC 10206:1990 (Extended Pascal) •  Nachfolger: –  Modula‐2 – Modulkonzept, Corou?nen –  Oberon – Objekte, Vererbung, Sprache für Systemprogrammierung auf Lilith‐Rechner Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 79 C •  ursprünglich zwischen 1969 und 1973 an den Bell Labs entwickelt –  Nachfolger von B (Ken Thompsons Implemen?erung von BCPL) –  erstes Ziel: Entwicklung von So\ware für PDP‐7 •  erstes Standardwerk: The C Programming Language Brian Kernighan, Dennis Ritchie (K&R) •  Standardisierung begann 1983; erster Standard 1989 (ANSI) –  1990 von ISO übernommen: ISO/IEC 9899:1990 •  Überarbeitung des Standards: ISO/IEC 9899:1999, 2011 –  Sprachversionen werden C89, C99 und C11 genannt •  Heute _die_ Sprache für Systemprogrammierung Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 80 40
29.01.2013
C Standardisierung •  Ursprüngliche Fassung: K&R –  Kernighan & Ritchie C •  1989: ANSI C (X3.159‐1989) – 
– 
– 
– 
Komitee X3J11 seit 1983 1990 normiert von ISO (ISO/IEC 9899:1990) 1995 Amendment 1 (ISO/IEC 9899:1990/AM1:1995) “ANSI C”, “C89”, “ISO C”, “standard C” •  1999: C99 (ISO/IEC 9899:1999) –  inline, neue Datentypen, Felder variabler Länge, ... •  2011: C11 (ISO/IEC 9899:2011) –  alignment, noreturn, mul?‐threading, sta?c asser?ons, ... Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 81 C++ •  Entwickelt in den 1980ern von Bjarne Stroustrup, AT&T Bell Labs –  ursprünglich „C with Classes“ –  cfront: Übersetzer von C++ nach C •  Ziel: Objektorien?erte Programmierung in C –  Klassen, Methoden, Mehrfachvererbung –  später auch Templates, Ausnahmebehandlung, Namespaces •  Standardisierung: ISO/IEC 14882:1998, ISO/IEC 14882:2011 Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 82 41
29.01.2013
Java •  1991 entwickelt von James Gosling –  ursprünglich „oak“ genannt –  Weiterentwicklung von C++ •  entwickelt als „reine“ objekt‐orien?erte Sprache –  Klassen sind das Hauptstrukturierungskonzept •  Sprachversionen werden von SUN definiert –  aktuelle Version: Java 6 –  Java gehört heute Oracle (wie SUN...) Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 83 Deklara?ve Programmierung • 
Programmierparadigma, bei dem Problembeschreibung im Vordergrund steht. –  Der Lösungsweg wird dann automa?sch ermiTelt. • 
Zu den deklara?ven Programmiersprachen gehören: – 
– 
– 
– 
– 
– 
– 
– 
• 
funk?onale Sprachen (z. B. LISP, ML, Miranda, Gofer, Haskell, Erlang) logische Sprachen (z. B. Prolog) funk?onal‐logische Sprachen (z. B. Babel, Escher, Curry, Oz) Datenflusssprachen (z. B. Val oder Linda) Synchrone Programmiersprachen (z. B. Lustre) Au›auwerkzeuge (z. B. make oder Ant) Transforma?onssprachen (z. B. XSLT) Abfragesprachen (z. B. SQL) Im Gegensatz zur impera?ven Programmierung, bei der das Wie im Vordergrund steht, fragt man in der deklara?ven Programmierung nach dem Was, das berechnet werden soll. Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 84 42
29.01.2013
Funk?onale Programmierung • 
Programmierparadigma, bei dem Programme ausschließlich aus Funk?onen bestehen. –  Funk?onen ohne Seiteneffekte; keine globalen Variablen im Programm –  Kommunika?on über Parameter/Rückgabewert –  Parallelisierbarkeit • 
Grundlage Lambda‐Kalkül. –  Funk?onale Sprachen bieten Sprachelemente zur Kombina?on und Transforma?on von Funk?onen –  Keine Schleifen + Zuweisungen; dafür Rekursion • 
Funk?onen höherer Ordnung: –  Funk?onen sind Werte –  Funk?onen als Ergebnisse oder Argumente anderer Funk?onen zu verwenden. –  Beispiel Ableitungsoperator: Eingabe ist eine differenzierbare Funk?on, Ausgabe ist die Ableitung dieser Funk?on. –  Beispiel map(f, l): wendet f auf jedes Listenelement von l an Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 85 Funk?onale Programmiersprachen • 
• 
• 
• 
• 
• 
• 
• 
LISP Scheme ML (Meta Language) Miranda Haskell OPAL ... Funk?onale Sprachen beinhalten o\ impera?ve Elemente –  z.B. Ein/Ausgabe Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 86 43
29.01.2013
Lisp •  List Processing Language •  entwickelt 1958 von John McCarthy –  erstmalig implemen?ert von Steve Russel für IBM 704 –  erster LISP‐Compiler 1962 (gemischter Interpreter/Compiler‐Betrieb) •  funk?onale Sprache: Ziel der Berechnung wird als Funk?onsausdruck formuliert –  primäre Datentypen: Listen, Zahlen, „Atome“ •  von Anfang an für KI (Künstliche Intelligenz) verwendet •  ursprünglich viele Sprachversionen (InterLisp, Franz Lisp, ...) –  ANSI‐Standard 1994: „Common Lisp“ Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 87 Beispiel Scheme • 
Berechnung der Fläche zwischen zwei konzentrischen Kreisen (define (ringarea r1 r2) (define pi 3.14) (define (sq x) (* x x)) (* pi (‐ (sq r1) (sq r2)))) • 
Alterna?v mit Funk?onen höherer Ordnung: (define (ringarea r1 r2) (* 3.14 (foldr ‐ 0 (map (lambda (x) (* x x)) (list r1 r2))))) • 
• 
map – Anwenden einer Funk?onauf jedes Listenelement foldr – akkumula?ve Opera?on unter Anwendung eines gegebenen Operators –  Zusammenfassen einer Liste Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 88 44
29.01.2013
Logische Programmierung •  Mathema?schen Logik als Grundlage –  Programm besteht aus einer Menge von Axiomen –  Reine Ansammlung von Fakten oder Annahmen –  Stellt der Benutzer eines Logik‐Programms eine Anfrage, so versucht der Interpreter die Lösungsaussage allein aus den Axiomen zu berechnen •  Fakten, Regeln und Anweisungen –  Ursprünge der logischen Programmierung: Künstliche Intelligenz. •  In einem logikbasierten Programm wird nur beschrieben, was gilt. Das Wie ist bereits durch die Lösungsmethode vorgegeben. –  Die Lösung wird aus den vorhandenen Regeln hergeleitet. –  Programm == Menge von Regeln –  Lösungsmethode wird durch Inferenzmaschine (Interpreter) implemen?ert •  Bekannteste Sprache: Prolog Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 89 Prolog •  um 1972 von Alain Colmerauer und Robert Kowalski entwickelt –  „programming in logic“ •  logische Programmiersprache –  basierend auf dem Prädikatenkalkül (PK1) •  verwendet für KI und Computerlinguis?k •  ISO/IEC 13211:1995 Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 90 45
29.01.2013
Beispiel Prolog •  Regeln: •  Fakten: vater(peter,maria). muTer(susanne,maria). vater(peter,monika). muTer(susanne,monika). vater(karl, peter). muTer(elisabeth, peter). vater(karl, pia). muTer(elisabeth, pia). vater(karl, paul). muTer(elisabeth, paul). eltern(X,Y) :‐ vater(X,Y). eltern(X,Y) :‐ muTer(X,Y). frau(maria). frau(elisabeth). frau(susanne). frau(monika). frau(pia). mann(peter). mann(karl). mann(paul). bruder(X,Y) :‐ mann(X),vater(Z,X),vater(Z,Y), not(X == Y), muTer(M,X),muTer(M,Y). schwester(X,Y) :‐ frau(X),vater(Z,X),vater(Z,Y), not(X == Y), muTer(M,X),muTer(M,Y). geschwister(X,Y) :‐ vater(Z,X),vater(Z,Y), not(X == Y), muTer(M,X),muTer(M,Y). Andreas Polze %%%%% einfach und terminierend vorfahr(X,Y) :‐ eltern(X,Y). vorfahr(X,Z) :‐ eltern(X,Y),vorfahr(Y,Z). Unit 4: Programmiersprachen, Programmiertechnik 1 91 Objektorien?erte Programmierung •  Smalltalk, C++, Objec?ve‐C, Java •  Alan Kay: The Early History of Smalltalk (1993) –  1. Alles ist ein Objekt, –  2. Objekte kommunizieren durch das Senden und Empfangen von Nachrichten (welche aus Objekten bestehen), –  3. Objekte haben ihren eigenen Speicher (strukturiert als Objekte), –  4. Jedes Objekt ist die Instanz einer Klasse (welche ein Objekt sein muss), –  5. Die Klasse beinhaltet das Verhalten aller ihrer Instanzen (in der Form von Objekten in einer Programmliste), –  6. Um eine Programmliste auszuführen, wird die Ausführungskontrolle dem ersten Objekt gegeben und das verbleibende als dessen Nachricht behandelt“ •  Variante der impera?ven Programmierung –  Besonders geeignet zur Darstellung von „realen Objekten“ (!) im Computer –  Benutzungsoberflächen, Simula?on Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 92 46
29.01.2013
Objekte und Klassen *class
*class
*class
Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 93 Zusammenfassung •  Spezifika?on, Algorithmen, Programme –  EBNF: Programme müssen syntak?sch korrekt sein –  Compiler überprü\ Korrektheit anhand einer formalen Gramma?k –  Compiler/Linker übersetzen Programm in Maschinencode •  Impera?ve Programmierung: C –  Zuweisung, Sequenz, Alterna?ve, Schleife – ausreichend für Turing‐Mäch?gkeit •  Deklara?ve Programmierung –  Geben das „Was“, nicht das „Wie“ beim Programmieren an –  Funk?onale Programmierung: Scheme –  Logische Programmierung: Prolog •  Objektorien?erte Programmierung: Smalltalk, C++, Objec?ve‐C, Java
–  Besonders gut für Darstellung „realer Objekte“ geeignet –  Impera?ver Programmiers?l Andreas Polze Unit 4: Programmiersprachen, Programmiertechnik 1 MuTersprache? 94 47