als PDF, 4 Folien/Seite - Fachgebiet Programmiersprachen

als PDF, 4 Folien/Seite - Fachgebiet Programmiersprachen
GPS-0-1
GPS-0-2
Ziele
Die Vorlesung soll Studierende dazu befähigen,
• die Grundkonzepte von Programmier- oder
Grundlagen der
Programmiersprachen
Anwendungssprachen zu verstehen,
• Sprachdefinitionen zu verstehen,
• neue Programmiersprachen und deren Anwendung
selbständig erlernen zu können
(dies wird an der Sprache C in der Vorlesung erprobt)
• typische Eigenschaften nicht-imperativer
Programmiersprachen zu verstehen.
• Freude am Umgang mit Sprachen haben.
Prof. Dr. Uwe Kastens
© 2014 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
Sommersemester 2015
GPS-0-3
GPS-0-4
Inhalt
Thema
Kapitel im Buch
Sebesta Mitchell
1, 2
Einführung
1
1, 4
3, 4
Definition Syntaktischer Strukturen
3
4
5
Gültigkeit von Definitionen,
4.4, 4.8
7.1
6
Lebensdauer von Variablen
Laufzeitkeller
4.9
7.2, 7.3
7, 8
Datentypen
4.5, 5
6
9
Aufruf, Parameterübergabe
8
10, 11, 12
Funktionale Programmierung:
Grundbegriffe, Rekursionsparadigmen,
Funktionen höherer Ordnung
14
3, 7.4
13, 14
Logische Programmierung:
Grundlagen,
Auswertung logischer Programme
15
15
Zusammenfassung
In GPS verwendete Kenntnisse aus
• Grundlagen der Programmierung 1, 2:
Eigenschaften von Programmiersprachen im allgemeinen
• Modellierung:
reguläre Ausdrücke, kontext-freie Grammatiken,
abstrakte Definition von Wertemengen, Terme, Unifikation
Kenntnisse aus GPS werden benötigt z. B. für
• weiterführende Veranstaltungen im Bereich Programmiersprachen und Übersetzer:
© 2015 bei Prof. Dr. Uwe Kastens
© 2013 bei Prof. Dr. Uwe Kastens
Vorlesung
Bezüge zu anderen Vorlesungen
Verständnis für Sprachkonzepte und -konstrukte
5. Sem: PLaC; Master: noch offen
• Software-Technik: Verständnis von Spezifikationssprachen
• Wissensbasierte Systeme: logische Programmierung, Prolog
• alle Veranstaltungen, die Programmier-, Spezifikations- oder Spezialsprachen
verwenden:
Grundverständnis für Sprachkonzepte und Sprachdefinitionen,
z. B. VHDL in GTI/GRA; SQL in Datenbanken
GPS-0-5
GPS-0-6
GPS-Literatur
Organisation: Das GPS-Skript im WWW
Zur Vorlesung insgesamt:
• elektronisches Skript GPS: http://ag-kastens.upb.de/lehre/material/gps
• R. W. Sebesta: Concepts of Programming Languages, 9th Ed., Pearson, 2010
• John C. Mitchell: Concepts in Programming Languages, Cambridge University Press, 2003
Zu Funktionaler Programmierung:
• L. C. Paulson: ML for the Working Programmer, 2nd ed., Cambridge University Press, 1996
Zu Logischer Programmierung:
• W.F. Clocksin and C.S. Mellish: Programming in Prolog , 5th ed. Springer, 2003
C, C++, Java:
• Carsten Vogt: C für Java-Programmierer, Hanser, 2007
• S.P. Harbison, G.L. Steele: C: A - Reference Manual (5th ed.), Prentice Hall, 2002
• K. Arnold, J. Gosling: The Java Programming Language, 4th Edition, Addison-Wesley, 2005
• Bracha, J. Gosling, B. Joy, G. L. Steele: The Java Language Specification, 3rd Edition,
Addison-Wesley, 2005
© 2015 bei Prof. Dr. Uwe Kastens
© 2011 bei Prof. Dr. Uwe Kastens
• Timothy Budd: C++ for Java Programmers, Pearson, 1999.
http://ag-kastens.upb.de/lehre/material/gps
GPS-0-7
GPS-0-8
Erläuterte Folien im Skript
Organisation im Sommersemester 2015
Termine
© 2015 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
Übungsbetreuer
Vorlesung
Die
14:15 - 15:45
Mi
14:15 - 15:45
Beginn: Mi. 27.05.
L2, Uwe Kastens
L2, Uwe Kastens
Zentralübung
Mi
13:15 - 14:00
Beginn: Mi 10. 6.
L2, Uwe Kastens
Übungen
Beginn: Mo 01.06.
Dr. Peter Pfahler
Felix Barczewicz
Aaron Nickl
Denis Diemert
Patrick Robrecht
Lukas Eilers
Jan-Niclas Strüwer
Übungstermine
siehe Organisationsseite des Vorlesungsmaterials im Web
gemäß Anmeldung in PAUL
Hausaufgaben
erscheinen wöchentlich (bis Die.), Bearbeitung in Gruppenarbeit (2-4),
Abgabe bis Die 14:15 Uhr; Lösungen werden korrigiert und bewertet.
1 Test
wird während einer Zentralübung durchgeführt (Termine im Web),
können bestandene Klausur um 1 - 2 Notenschritte verbessern.
Klausur
voraussichtliche Termine: 21.07. und im September
Anmeldung in PAUL / ZPS
GPS-1-2
GPS-1-1
1. Einführung
1.1 Zeitliche Einordnung, Klassifikation von Programmiersprachen
imperative Sprachen
funktionale
objektorientierte
Sprachen
Sprachen
logische
Sprache
1950
Themen dieses Kapitels:
1.1.
Zeitliche Einordnung, Klassifikation
von Programmiersprachen
1.2.
Implementierung von Programmiersprachen
1.3.
Dokumente zu Programmiersprachen
1.4.
Vier Ebenen der Spracheigenschaften
Fortran
1960
1970
Cobol
Algol 60
PL/1
Algol 68
Auszeichnungssprachen
Skriptsprachen
Lisp
Simula
Prolog
Smalltalk
Pascal
Unix sh
awk
C
1980
SML
Ada
C++
Self
Miranda
Eiffel
1990
© 2015 bei Prof. Dr. Uwe Kastens
C#
F#
Tcl
Python
JavaScript
Ada 95
2000
Perl
Haskell
Java
© 2009 bei Prof. Dr. Uwe Kastens
SGML
PHP
HTML-1
XML
HTML-4
Scala
nach [D. A. Watt: Programmiersprachen, Hanser, 1996; Seite 5] und [Computer Language History http://www.levenez.com/lang]
GPS-1-3a
GPS-1-3b
Klassifikation: Imperative Programmiersprachen
imperative Sprachen
1950
Fortran
1960
1970
Cobol
Algol 60
PL/1
Algol 68
Pascal
Klassifikation: objektorientierte Programmiersprachen
charakteristische Eigenschaften:
objektorientierte
Sprachen
1950
charakteristische Eigenschaften:
Klassen mit Methoden und Attributen,
Objekte zu Klassen
Variable mit Zuweisungen,
veränderbarer Programmzustand,
Vererbungsrelation zwischen Klassen
1960
Ablaufstrukturen (Schleifen, bedingte
Anweisungen, Anweisungsfolgen)
Typen:
objektorientierte Polymorphie:
Objekt einer Unterklasse kann verwendet
werden, wo ein Objekt der Oberklasse
benötigt wird
Simula
Funktionen, Prozeduren
1970
implementiert durch Übersetzer
Smalltalk
C
1980
1980
Ada
dynamische Methodenbindung
C++
Self
Self und JavaScript haben keine Klassen;
Vererbung zwischen Objekten
Eiffel
1990
Python
Java
Ada 95
2000
nach [D. A. Watt: Programmiersprachen, Hanser, 1996; Seite 5]
[Computer Language History http://www.levenez.com/lang]
JavaScript
Ada 95
© 2015 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
1990
2000
C#
F#
Scala
nach [D. A. Watt: Programmiersprachen, Hanser, 1996; Seite 5]
[Computer Language History http://www.levenez.com/lang]
Fast alle oo Sprachen haben auch
Eigenschaften imperativer Sprachen
implementiert:
Übersetzer: Simula, C++, Eiffel, Ada
Übersetzer + VM: Smalltalk, Java, C#
Interpretierer: Self, Python, JavaScript
GPS-1-3c
GPS-1-3d
Klassifikation: logische Programmiersprachen
Klassifikation: funktionale Programmiersprachen
charakteristische Eigenschaften:
1950
logische
Sprache
funktionale
Sprachen
Prädikatenlogik als Grundlage
Deklarative Programme ohne Ablaufstrukturen,
bestehen aus Regeln, Fakten und Anfragen
1960
Lisp
1960
1970
keine Zustandsänderungen
keine Seiteneffekte
Prolog
SML
1980
keine Typen
1980
implementiert durch Interpretierer
Miranda
1990
Haskell
© 2015 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
1990
2000
nach [D. A. Watt: Programmiersprachen, Hanser, 1996; Seite 5]
[Computer Language History http://www.levenez.com/lang]
rekursive Funktionen,
Funktionen höherer Ordnung
d.h. Funktionen als Parameter oder als Ergebnis
Deklarative Programme ohne Ablaufstrukturen;
Funktionen und bedingte Ausdrücke
Variable ohne Zuweisungen, erhalten Werte
durch Termersetzung und Unifikation
1970
charakteristische Eigenschaften:
1950
2000
F#
Scala
Variable ohne Zuweisungen,
erhalten Werte durch Deklaration oder
Parameterübergabe
keine Zustandsänderung,
keine Seiten-Effekte
Typen:
Lisp: keine
SML, Haskell: parametrische Polymorphie
implementiert durch
Lisp: Interpretierer
sonst: Übersetzer und/oder Interpretierer
nach [D. A. Watt: Programmiersprachen, Hanser, 1996; Seite 5]
[Computer Language History http://www.levenez.com/lang]
GPS-1-3e
GPS-1-3f
Klassifikation: Skriptsprachen
Klassifikation: Auszeichnungssprachen
charakteristische Eigenschaften:
1950
Skriptsprachen
1960
1950
Ziel: einfache Entwicklung einfacher
Anwendungen (im Gegensatz zu allgemeiner
Software-Entwicklung),
insbes. Textverarbeitung und Web-Anwendungen
Auszeichnungssprachen
Unix sh
awk
1980
Perl
1990
Tcl
SGML
Typen:
dynamisch typisiert, d.h. Typen werden bei
Programmausführung bestimmt und geprüft
implementiert durch Interpretierer
ggf integriert in Browser und/oder Web-Server
1990
Python
JavaScript
PHP
2000
nach [D. A. Watt: Programmiersprachen, Hanser, 1996; Seite 5]
[Computer Language History http://www.levenez.com/lang]
ggf Programme eingebettet in HTML-Texte
Sprachkonstrukte:
Baum-strukturierte Texte, Klammerung durch
Tags, Attribute zu Textelementen
keine Ablaufstrukturen, Variable, Datentypen zur
Programmierung
1980
© 2015 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
1970
Python, JavaScript und spätes PHP auch oo
Annotierung von Texten zur Kennzeichnung der
Struktur, Formatierung, Verknüpfung
Ziele: Repräsentation strukturierter Daten (XML),
Darstellung von Texten, Hyper-Texten, WebSeiten (HTML)
1960
Ablaufstrukturen, Variable und Zuweisungen wie
in imperativen Sprachen
1970
charakteristische Eigenschaften:
HTML-1
XML
HTML-4
2000
nach [D. A. Watt: Programmiersprachen, Hanser, 1996; Seite 5]
[Computer Language History http://www.levenez.com/lang]
Ggf. werden Programmstücke in Skriptsprachen
als spezielle Textelemente eingebettet und beim
Verarbeiten des annotierten Textes ausgeführt.
GPS-1-4
GPS-1-5a
Eine Funktion in verschiedenen Sprachen
Hello World in vielen Sprachen
Sprache A:
function Length (list: IntList): integer;
var len: integer;
begin
len := 0;
while list <> nil do
begin len := len + 1; list := list^.next end;
Length := len
end;
COBOL
Sprache B:
int Length (Node list)
{ int len = 0;
while (list != null)
{ len += 1; list = list.link; }
return len;
}
Sprache C:
fun Length list =
if null list then 0
else 1 + Length (tl list);
PROGRAM HELLO
DO 10, I=1,10
PRINT *,'Hello World'
10 CONTINUE
STOP
END
Pascal
Program Hello (Input, Output);
Begin
repeat
writeln('Hello World!')
until 1=2;
End.
C
© 2011 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
FORTRAN IV
000100 IDENTIFICATION DIVISION.
000200 PROGRAM-ID.
HELLOWORLD.
000300 DATE-WRITTEN.
02/05/96
21:04.
000400*
AUTHOR
BRIAN COLLINS
000500 ENVIRONMENT DIVISION.
000600 CONFIGURATION SECTION.
000700 SOURCE-COMPUTER. RM-COBOL.
000800 OBJECT-COMPUTER. RM-COBOL.
000900
001000 DATA DIVISION.
001100 FILE SECTION.
001200
100000 PROCEDURE DIVISION.
100100
100200 MAIN-LOGIC SECTION.
100300 BEGIN.
100400
DISPLAY “ “ LINE 1 POSITION 1 ERASE EOS.
100500
DISPLAY “HELLO, WORLD.“ LINE 15 POSITION 10.
100600
STOP RUN.
100700 MAIN-LOGIC-EXIT.
100800
EXIT.
Sprache D:
length([], 0).
length([Head | Tail], Len):length(Tail, L), Len IS L + 1.
main()
{ for(;;)
{ printf ("Hello World!\n");
}
}
Perl
Java
class HelloWorld {
public static void main (String args[]) {
for (;;) {
System.out.print("HelloWorld");
}
}
}
print "Hello, World!\n" while (1);
GPS-1-5b
GPS-1-6
Hello World in vielen Sprachen
Sprachen für spezielle Anwendungen
Lisp
Prolog
hello :printstring("HELLO WORLD!!!!").
printstring([]).
printstring([H|T]) :- put(H), printstring(T).
HTML
SQL
CREATE TABLE HELLO (HELLO CHAR(12))
UPDATE HELLO
SET HELLO = 'HELLO WORLD!'
SELECT * FROM HELLO
<HTML>
<HEAD>
<TITLE>Hello, World Page!</TITLE>
</HEAD>
<BODY>
Hello, World!
</BODY>
</HTML>
Make
while (/bin/true)
do
echo "Hello, World!"
done
LaTex
\documentclass{article}
\begin{document}
\begin{center}
\Huge{HELLO WORLD}
\end{center}
\end{document}
FORTRAN, Algol-60
• kaufmännisch
RPG, COBOL
• Datenbanken:
SQL
• Vektor-, Matrixrechnungen:
APL, Lotus-1-2-3
• Textsatz:
TeX, LaTeX, PostScript
• Textverarbeitung, Pattern Matching:
SNOBOL, ICON, awk, Perl
• Skriptsprachen:
DOS-, UNIX-Shell, TCL, Perl, PHP
• Auszeichnung (Markup):
HTML, XML
Bourne Shell (Unix)
PostScript
/Font /Helvetica-Bold findfont def
/FontSize 12 def
Font FontSize scalefont setfont
{newpath 0 0 moveto (Hello, World!) show showpage} loop
© 2011 bei Prof. Dr. Uwe Kastens
© 2011 bei Prof. Dr. Uwe Kastens
default:
echo "Hello, World\!"
make
• technisch/wissenschaftlich:
(DEFUN HELLO-WORLD ()
(PRINT (LIST ‚HELLO ‚WORLD)))
• Spezifikationssprachen:
SETL, Z
VHDL
UML
EBNF
Allgemeine Spezifikationen von Systemen
Spezifikationen von Hardware
Spezifikationen von Software
Spezifikation von KFGn, Parsern
GPS-1-8
GPS-1-8a
1.2 Implementierung von Programmiersprachen
Übersetzung
Programmentwicklung
Interpretation
Übersetzung
Programmentwicklung
Editor
Ausführung
Editor
ggf. Präprozessor
Quellmodul
ggf. mit Präprozessor-Anweisungen
Quellprogramm
Übersetzer
Fehlermeldungen
Interpretierer
lexikalische Analyse
syntaktische Analyse
semantische Analyse
lexikalische Analyse
syntaktische Analyse
semantische Analyse
Fehlermeldungen
Zwischen-Code
Optimierung
Code-Erzeugung
Bibliotheksmodule
virtuelle Maschine
(Prozessor in Software)
Ausgabe
Ausführung
ausführbarer Code
Eingabe
Maschine
© 2009 bei Prof. Dr. Uwe Kastens
© 2009 bei Prof. Dr. Uwe Kastens
Eingabe
bindbarer Modul-Code
Binder
Binden
Code als Datenstruktur
Fehlermeldungen
Ausgabe
GPS-1-9
GPS-1-8b
Testhilfe: Debugger
Präprozessor CPP
Präprozessor:
• bearbeitet Programmtexte, bevor sie vom Übersetzer verarbeitet werden
interaktive Kommandos
• Kommandos zur Text-Substitution - ohne Rücksicht auf Programmstrukturen
Debugger
Quellmodule
• sprachunabhängig
Anzeige von
Speicher
und Code
• cpp gehört zu Implementierungen von C und C++, kann auch unabhängig benutzt werden
#include <stdio.h>
#include "induce.h"
ausführbarer
Code
Ausgabe
© 2005 bei Prof. Dr. Uwe Kastens
© 2009 bei Prof. Dr. Uwe Kastens
Eingabe
schrittweise Ausführung;
Transformation von
Daten und Programm
auf Niveau
der Quellsprache
#define MAXATTRS
256
#define ODD(x)
#define EVEN(x)
((x)%2 == 1)
((x)%2 == 0)
Datei an dieser Stelle einfügen
benannte Konstante
parametrisiertes Text-Makro
static void early (int sid)
{ int attrs[MAXATTRS];
Konstante wird substituiert
...
if (ODD (currpartno)) currpartno--;
Makro wird substituiert
#ifndef GORTO
bedingter Textblock
printf ("early for %d currpartno: %d\n",
sid, currpartno);
#endif
GPS-1-10
GPS1-11
Ausführung von Java-Programmen
1.3 Dokumente zu Programmiersprachen
Reference Manual:
verbindliche Sprachdefinition, beschreibt alle Konstrukte und Eigenschaften vollständig und
präzise
Editor
Quellmodul
m1.java
JavaÜbersetzer
m2.class
Standard Dokument:
Reference Manual, erstellt von einer anerkannten Institution, z.B. ANSI, ISO, DIN, BSI
formale Definition:
für Implementierer und Sprachforscher,
verwendet formale Kalküle, z.B. KFG, AG, vWG, VDL, denotationale Semantik
m3.class
m1.class
Java Modulbibliotheken
auf Rechnern am
Internet
Zielmodule
in Java-Bytecode
Benutzerhandbuch (Rationale):
Erläuterung typischer Anwendungen der Sprachkonstrukte
Internet
Eingabe
Klassenlader
Lehrbuch:
didaktische Einführung in den Gebrauch der Sprache
Java-Bytecode ist maschinenunabhängig
von Java Virtual Machine (JVM) ausgeführt
interpretiert Bytecode
Java-Bytecode
Interpretierer
Ausgabe
Just-in-Time
Compiler
MaschinenCode
übersetzt Bytecode-Methoden
bevor sie (wieder) aufgerufen
werden
© 2009 bei Prof. Dr. Uwe Kastens
© 2007 bei Prof. Dr. Uwe Kastens
Browser
Implementierungsbeschreibung:
Besonderheiten der Implementierung, Abweichungen vom Standard, Grenzen,
Sprachwerkzeuge
GPS-1-12
GPS-1-13
Beispiel für ein Standard-Dokument
6.1 Labeled statement
Beispiel für eine formale Sprachdefinition
[stmt.label]
A statement can be labeled.
labeled-statement:
identifier : statement
case constant-expression : statement
default : statement
[Aus einem C++-Normentwurf, 1996]
Begriffe zu Gültigkeitsregeln, statische Semantik (siehe Kapitel 3).
::= ( Klausel | Direktive )+ .
Klausel
::= Fakt | Regel .
Fakt
::= Atom | Struktur .
Regel
::= Kopf ":-" Rumpf "." .
Direktive
::=
|
|
|
":-" Rumpf
"?-" Rumpf
"-" CompilerAnweisung
"?-" CompilerAnweisung .
[Spezifikation einer Syntax für Prolog]
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
An identifier label declares the identifier. The only use of an identifier label is as the
target of a goto. The scope of a label is the function in which it appears. Labels shall not be
redeclared within a function. A label can be used in a goto statement before its definition.
Labels have their own name space and do not interfere with other identifiers.
Prologprogramm
GPS-1-14
GPS-1-15
Beispiel für ein Benutzerhandbuch
Beispiel für ein Lehrbuch
Chapter 1, The Message Box
This is a very simple script. It opens up an alert message box which displays whatever is typed
in the form box above. Type something in the box. Then click „Show Me“
R.5. Ausdrücke
Die Auswertungsreihenfolge von Unterausdrücken wird von den Präzedenz-Regeln und der
Gruppierung bestimmt. Die üblichen mathematischen Regeln bezüglich der Assoziativität und
Kommutativität können nur vorausgesetzt werden, wenn die Operatoren tatsächlich assoziativ
und kommutativ sind. Wenn nicht anders angegeben, ist die Reihenfolge der Auswertung der
Operanden undefiniert. Insbesondere ist das Ergebnis eines Ausdruckes undefiniert, wenn
eine Variable in einem Ausdruck mehrfach verändert wird und für die beteiligten Operatoren
keine Auswertungsreihenfolge garantiert wird.
HOW IT‘S DONE
Here‘s the entire page, minus my comments. Take a few minutes to learn as much as you can
from this, then I‘ll break it down into smaller pieces.
i = v[i++];
// der Wert von i ist undefiniert
i = 7, i++, i++;
// i hat nach der Anweisung den Wert 9
[Aus dem C++-Referenz-Handbuch, Stroustrup, 1992]
Eigenschaften der dynamischen Semantik
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
Beispiel:
<HTML> <HEAD>
<SCRIPT LANGUAGE=“JavaScript“>
function MsgBox (textstring) {alert (textstring)}
</SCRIPT>
</HEAD> <BODY>
<FORM> <INPUT NAME=“text1“ TYPE=Text>
<INPUT NAME=“submit“ TYPE=Button VALUE=“Show Me“
onClick=“MsgBox(form.text1.value)“>
</FORM>
</BODY> </HTML>
[Aus einem JavaScript-Tutorial]
GPS-1-16
GPS-1-17a
1.4 Vier Ebenen der Spracheigenschaften
Beispiel für die Ebene der Grundsymbole
Die Eigenschaften von Programmiersprachen werden in 4 Ebenen eingeteilt:
Ebene
Von a über b nach c werden immer größere Zusammenhänge im Programm
betrachtet. In d kommt die Ausführung des Programmes hinzu.
Ebene
Notation
b. Syntax (konkret und abstrakt)
Struktur
c. Statische Semantik
d. Dynamische Semantik
typische Klassen von Grundsymbolen:
Bezeichner,
Literale (Zahlen, Zeichenreihen),
Wortsymbole,
Spezialsymbole
definierte Eigenschaften
a. Grundsymbole
definierte Eigenschaften
a. Grundsymbole
formal definiert z. B. durch reguläre Ausdrücke
statische Zusammenhänge
Folge von Grundsymbolen:
Wirkung, Bedeutung
© 2010 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
int dupl ( int a ) { return 2 * a ; }
Notation
GPS-1-17b
GPS-1-17c
Beispiel für die Ebene der Syntax
Ebene
Beispiel für die Ebene der statischen Semantik
Ebene
definierte Eigenschaften
b. Syntax (konkrete und abstrakte Syntax)
Struktur von Sprachkonstrukten
syntaktische Struktur
definierte Eigenschaften
c. statische Semantik
statische Zusammenhänge, z. B.
meist verbal definiert;
formal definiert z. B. durch attributierte Grammatiken
formal definiert durch kontext-freie Grammatiken
a ist an die Definition des formalen Parameters gebunden.
Bindung von Namen
Der return-Ausdruck hat den gleichen Typ
Ausschnitt aus einem Ableitungs- bzw. Strukturbaum:
Typregeln
wie der ResultType.
MethodDeclaration
MethodHeader
MethodBody
MethodDeclaration
MethodDeclarator
ResultType
Identifier ( FormalParameterList )
...
int a
...
{ return 2*a; }
© 2010 bei Prof. Dr. Uwe Kastens
dupl
ResultType
© 2010 bei Prof. Dr. Uwe Kastens
int
MethodHeader
MethodBody
MethodDeclarator
Identifier ( FormalParameterList )
...
int
dupl
int a
...
{ return 2*a; }
GPS-1-17d
GPS-1-18
Beispiel für die Ebene der dynamischen Semantik
Ebene
Statische und dynamische Eigenschaften
definierte Eigenschaften
d. dynamische Semantik
Statische Eigenschaften: aus dem Programm bestimmbar, ohne es auszuführen
Bedeutung, Wirkung der Ausführung
von Sprachkonstrukten, Ausführungsbedingungen
statische Spracheigenschaften:
Ebenen a, b, c: Notation, Syntax, statische Semantik
meist verbal definiert;
formal definiert z. B. durch denotationale Semantik
statische Eigenschaften eines Programmes:
Anwendung der Definitionen zu a, b, c auf das Programm
Ein Aufruf der Methode dupl liefert das Ergebnis
der Auswertung des return-Ausdruckes
Ein Programm ist übersetzbar, falls es die Regeln zu (a, b, c) erfüllt.
Dynamische Eigenschaften: beziehen sich auf die Ausführung eines Programms
dynamische Spracheigenschaften:
Ebene d: dynamische Semantik
MethodDeclaration
MethodHeader
MethodBody
Identifier ( FormalParameterList )
...
int
dynamische Eigenschaften eines Programmes:
Wirkung der Ausführung des Programmes mit bestimmter Eingabe
MethodDeclarator
dupl
int a
...
{ return 2*a; }
© 2005 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
ResultType
Ein Programm ist ausführbar, falls es die Regeln zu (a, b, c) und (d) erfüllt.
GPS-1-18a
GPS-1-19
Beispiel: Dynamische Methodenbindung in Java
Fehler im Java-Programm
Fehler klassifizieren: lexikalisch, syntaktisch, statisch oder dynamisch semantisch:
class A {
void draw (int i){...};
void draw () {...}
}
statisch wird am Programmtext bestimmt:
• der Methodenname: draw
class B extends A {
void draw () {...}
}
• der statische Typ von a: A
class X {
void m () {
A a;
if (...)
a = new A ();
else a = new B ();
• draw() in B überschreibt draw() in A
a.draw ();
• die Typen der aktuellen Parameter: keine
• ist eine Methode draw ohne Parameter in A
oder einer Oberklasse definiert? ja
dynamisch wird bei der Ausführung bestimmt:
• der Wert von a:
z. B. Referenz auf ein B-Objekt
• der Typ des Wertes von a: B
}
• die aufzurufende Methode: draw aus B
}
© 2005 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
Für den Aufruf einer Methode kann im Allgemeinen erst beim Ausführen des
Programms bestimmt werden, welche Methode aufgerufen wird.
1
class Error
2
{ private static final int x = 1..;
3
public static void main (String [] arg)
4
{ int[] a = new int[10];
5
int i
6
boolean b;
7
x = 1; y = 0; i = 10;
8
a[10] = 1;
9
b = false;
10
if (b) a[i] = 5;
11
12
}
}
GPS-1-20
GPS-1-21
Fehlermeldungen eines Java-Übersetzers
Zusammenfassung zu Kapitel 1
Error.java:2: <identifier> expected
{ private static final int x = 1..;
^
Mit den Vorlesungen und Übungen zu Kapitel 1 sollen Sie nun Folgendes können:
Error.java:5: ';' expected
int i
^
• Wichtige Programmiersprachen zeitlich einordnen
Error.java:2: double cannot be dereferenced
{ private static final int x = 1..;
^
• Programmiersprachen klassifizieren
• Sprachdokumente zweckentsprechend anwenden
Error.java:7: cannot assign a value to final variable x
x = 1; y = 0; i = 10;
^
• Sprachbezogene Werkzeuge kennen
Error.java:9: cannot resolve symbol
symbol : variable b
location: class Error
b = false;
^
Error.java:10: cannot resolve symbol
symbol : variable b
location: class Error
if (b) a[i] = 5;
^
7 errors
• Spracheigenschaften und Programmeigenschaften in die 4 Ebenen einordnen
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
Error.java:7: cannot resolve symbol
symbol : variable y
location: class Error
x = 1; y = 0; i = 10;
^
GPS-2-1
GPS-2-2
2. Syntax
2.1 Grundsymbole
Grundsymbole:
Programme bestehen aus einer Folge von Grundsymbolen. (Ebene (a) auf GPS-1-16)
Jedes Grundsymbol ist eine Folge von Zeichen.
Ihre Schreibweise wird z.B. durch reguläre Ausdrücke festgelegt.
Grundsymbole sind die Terminalsymbole der konkreten Syntax. (Ebene (b) GPS-1-16)
Themen dieses Kapitels:
• 2.1 Grundsymbole
• 2.2 Kontext-freie Grammatiken
•
Schema für Ausdrucksgrammatiken
Folgende 4 Symbolklassen sind typisch für Grundsymbole von Programmiersprachen:
Bezeichner, Wortsymbole, Literale, Spezialsymbole
•
Erweiterte Notationen für kontext-freie Grammatiken
1. Bezeichner (engl. identifier):
•
Entwurf einfacher Grammatiken
•
abstrakte Syntax
zur Angabe von Namen, z. B.
maximum
Definition einer Schreibweise durch reg. Ausdruck:
findValue
res_val
_MIN2
Buchstabe (Buchstabe | Ziffer)*
2. Wortsymbole (engl. keywords):
• 2.3 XML
kennzeichnen Sprachkonstrukte
© 2015 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
Schreibweise fest vorgegeben; meist wie Bezeichner, z. B.class static if for
Dann müssen Bezeichner verschieden von Wortsymbolen sein.
Nicht in PL/1; dort unterscheidet der Kontext zwischen Bezeichener und Wortsymbol:
IF THEN THEN THEN = ELSE ELSE ELSE = THEN;
Es gibt auch gekennzeichnete Wortsymbole, z.B.
$begin
GPS-2-2a
GPS-2-3
Literale und Spezialsymbole
Trennung von Grundsymbolen
2. Literale (engl. literals):
In den meisten Sprachen haben
die Zeichen Zwischenraum, Zeilenwechsel, Tabulator und Kommentare
keine Bedeutung außer zur Trennung von Grundsymbolen; auch white space genannt.
z. B.
int pegel;
statt intpegel;
Notation von Werten, z. B.
ganze Zahlen:
Gleitpunktzahlen:
Zeichen:
Zeichenreihen:
7
077
0xFF
3.7e-5
0.3
'x'
'\n'
"Hallo"
Unterscheide Literal und sein Wert: "Sage \"Hallo\""und
verschiedene Literale - gleicher Wert: 63
077
0x3F
Ausnahme Fortran:
Zwischenräume haben auch innerhalb von Grundsymbolen keine Bedeutung
z. B. Zuweisung DO 5 I = 1.5
gleichbedeutend wie DO5I=1.5 aber
Schleifenkopf
DO 5 I = 1,5
Sage "Hallo"
In Fortran, Python, Occam können Anweisungen
durch Zeilenwechsel getrennt werden.
In Occam und Python werden Anweisungen durch
gleiche Einrücktiefe zusammengefasst
Schreibweisen werden durch reguläre Ausdrücke festgelegt
4. Spezialsymbole (engl. separator, operator):
Operatoren, Trenner von Sprachkonstrukten, z. B.
; , = * <=
Häufigste Schreibweisen von Kommentaren:
geklammert , z. B.
int pegel; /* geklammerter Kommentar */
Bezeichner und Literale tragen außer der Klassenzugehörigkeit weitere Information:
Identität des Bezeichners und Wert des Literals.
Wortsymbole und Spezialsymbole stehen nur für sich selbst, tragen keine weitere Information.
© 2009 bei Prof. Dr. Uwe Kastens
Schreibweise festgelegt, meist Folge von Sonderzeichen
© 2009 bei Prof. Dr. Uwe Kastens
if (x < y)
a = x
b = y
print (x)
oder Zeilenkommentar bis zum Zeilenende, z. B.
int pegel; // Zeilenkommentar
Geschachtelte Kommentare z.B. in Modula-2:
/* aeusserer /* innerer */ Kommentar */
GPS-2-4
GPS-2-4a
2.2 Kontext-freie Grammatiken; Definition
KFG Beispiel: Grammatik für arithmetische Ausdrücke
Kontext-freie Grammatik (KFG, engl. CFG):
formaler Kalkül zur Definition von Sprachen und von Bäumen
GaA = (T, N, P, S) besteht aus:
T
N
S∈N
P ⊆ N × V*
Die konkrete Syntax einer Programmiersprache oder anderen formalen Sprache wird
durch eine KFG definiert. (Ebene b, GPS 1-16)
Die Strukturbäume zur Repräsentation von Programmen in Übersetzern werden als
abstrakte Syntax durch eine KFG definiert.
T
Menge der Terminalsymbole
Daraus bestehen Sätze der Sprache;
Grundsymbole
N
Menge der Nichtterminalsymbole
Daraus werden Sprachkonstrukte
abgeleitet.
S∈N
Startsymbol (auch Zielsymbol)
Daraus werden Sätze abgeleitet.
Regeln der Grammatik.
außerdem wird V = T ∪ Nals Vokabular definiert; T und N sind disjunkt
© 2009 bei Prof. Dr. Uwe Kastens
© 2009 bei Prof. Dr. Uwe Kastens
{ '(', ')', '+', '-', '*', '/', Ident }
{ Expr, Fact, Opd, AddOpr, MulOpr}
Expr
P Menge der Produktionen:
Eine kontext-freie Grammatik G = (T, N, P, S) besteht aus:
P ⊆ N × V* Menge der Produktionen
Terminalsymbole
Nichtterminalsymbole
Startsymbol
Produktionen
Produktionen haben also die Form A ::= x, mit A ∈ N und x ∈ V*
d.h. x ist eine evtl. leere Folge von Symbolen des Vokabulars.
Häufig gibt man Produktionen Namen: p1:
p2:
p3:
p4:
p5:
Unbenannte Terminalsymbole
p6:
kennzeichnen wir in Produktionen,
p7:
z.B. '+'
p8:
p9:
p10:
Expr ::=
Expr ::=
Fact ::=
Fact ::=
Opd
::=
Opd
::=
AddOpr ::=
AddOpr ::=
MulOpr ::=
MulOpr ::=
Expr AddOpr Fact
Fact
Fact MulOpr Opd
Opd
'(' Expr ')'
Ident
'+'
'-'
'*'
'/'
Es werden meist nur die Produktionen (und das Startsymbol)
einer kontext-freien Grammatik angegeben, wenn sich die übrigen
Eigenschaften daraus ergeben.
GPS-2-5
GPS-2-6
Beispiel für eine Ableitung
Ableitungen
Produktionen sind Ersetzungsregeln:
Ein Nichtterminal A in einer Symbolfolge u A v kann durch die rechte Seite x einer
Produktion A ::= x ersetzt werden.
Satz der Ausdrucksgrammatik b + c
Ableitung:
Ableitungsbaum:
Expr
Das ist ein Ableitungsschritt u A v ⇒ u x v
z. B. Expr AddOpr Fact ⇒ Expr AddOpr Fact MulOpr Opd mit Produktion p3
p1
=> Expr
Addopr Fact
Expr
Beliebig viele Ableitungsschritte nacheinander angewandt heißen Ableitung: u ⇒* v
p2
=> Fact
Addopr Fact
Fact
p4
=> Opd
Addopr Fact
Opd
p6
=> Ident
Addopr Fact
Ident
p7
=> Ident
+
Fact
p4
=> Ident
+
Opd
Opd
p6
=> Ident
+
Ident
Ident
+
c
Expr
Eine kontext-freie Grammatik definiert eine Sprache, d. h. die Menge von
Terminalsymbolfolgen, die aus dem Startsymbol S ableitbar sind:
L(G) = { w | w ∈ T* und S ⇒* w }
Addopr
+
Die Grammatik aus GPS-2-4a definiert z. B. Ausdrücke als Sprachmenge:
{ Ident, Ident + Ident, Ident + Ident * Ident } ⊂ L(G)
oder mit verschiedenen Bezeichnern für die Vorkommen des Grundsymbols Ident:
{ a, b + c, a + b * c } ⊂ L(G)
© 2006 bei Prof. Dr. Uwe Kastens
© 2009 bei Prof. Dr. Uwe Kastens
L(G) = { w | w ∈ T* und Expr ⇒* w }
b
Fact
b
+
c
GPS-2-8
GPS-2-7
Ableitungsbäume
Mehrdeutige kontext-freie Grammatik
Jede Ableitung kann man als Baum darstellen. Er definiert die Struktur des Satzes.
Die Knoten repräsentieren Vorkommen von Terminalen und Nichtterminalen.
Ein Ableitungsschritt mit einer Produktion wird dargestellt durch Kanten zwischen dem
Knoten für das Symbol der linken und denen für die Symbole der rechten Seite der Produktion:
Opd
p3
Fact MulOpr
p4
p9
Opd
p6
Ident
a
Expr ::= Expr '-' Expr
p5
Expr
( Expr )
*
ein Satz, der 2 verschiedene Ableitungsbäume
hat:
Expr ::= Number
Opd
Expr
p1
Expr
p2
Fact
AddOpr
p7
+
p4
Opd
p6
Ident
b
© 2005 bei Prof. Dr. Uwe Kastens
Beispiel für eine mehrdeutige KFG:
Expr
Fact
p4
Opd
-
Expr
Number
p6
Ident
c
© 2005 bei Prof. Dr. Uwe Kastens
Fact
p3
Fact MulOpr
Ableitungsbaum für
a * ( b + c )
Expr
p2
Fact
Anwendung der Produktion p3:
Eine kontext-freie Grammatik ist genau dann mehrdeutig, wenn
es einen Satz aus ihrer Sprache gibt,
zu dem es zwei verschiedene Ableitungsbäume gibt.
Expr
-
-
Number
a
Expr
-
Number
b
-
Expr
-
Number
c
Expr
-
Expr
Number
Number
-
Expr
-
c
a
-
b
GPS-2-10
GPS-2-9
Ausdrucksgrammatik
Schemata für Ausdrucksgrammatiken
Ausdrucksgrammatiken konstruiert man schematisch,
sodass strukturelle Eigenschaften der Ausdrücke definiert werden:
Die Struktur eines Satzes wird durch seinen Ableitungsbaum bestimmt.
Ausdrucksgrammatiken legen dadurch die Präzedenz und Assoziativität von Operatoren fest.
Im Beispiel hat AddOpr geringere Präzedenz als MulOpr, weil er
höher in der Hierarchie der Kettenproduktionen Expr ::= Fact, Fact ::= Opd steht.
p1
Expr
p2
Fact
© 2005 bei Prof. Dr. Uwe Kastens
p4
Opd
p6
Ident
a
AddOpr
p7
Fact
p3
+ Fact MulOpr
p4
p9
Opd
p6
Ident
b
*
Opd
p6
Ident
c
Name
p1:
p2:
p3:
p4:
p5:
p6:
p7:
p8:
p9:
p10:
Produktion
Expr
::=
Expr
::=
Fact
::=
Fact
::=
Opd
::=
Opd
::=
AddOpr ::=
AddOpr ::=
MulOpr ::=
MulOpr ::=
Expr AddOpr Fact
Fact
Fact MulOpr Opd
Opd
'(' Expr ')'
Ident
'+'
'-'
'*'
'/'
Im Beispiel sind AddOpr und MulOpr links-assoziativ, weil ihre Produktionen links-rekursiv
sind, d. h. a + b - c entspricht (a + b) - c.
© 2005 bei Prof. Dr. Uwe Kastens
Expr
eine Präzedenzstufe, binärer
Operator, linksassoziativ:
eine Präzedenzstufe, binärer
Operator, rechtsassoziativ:
A ::= A Opr B
A ::= B
A ::= B Opr A
A ::= B
eine Präzedenzstufe,
unärer Operator, präfix:
eine Präzedenzstufe,
unärer Operator, postfix:
A ::= Opr A
A ::= B
A ::= A Opr
A ::= B
Elementare Operanden: nur aus
dem Nichtterminal der höchsten
Präzedenzstufe (sei hier H)
abgeleitet:
Geklammerte Ausdrücke: nur aus
dem Nichtterminal der höchsten
Präzedenzstufe (sei hier H) abgeleitet;
enthalten das Nichtterminal der
niedrigsten Präzedenzstufe (sei hier A)
H ::= Ident
H ::= '(' A ')'
GPS-2-11
GPS-2-12
Notationen für kontext-freie Grammatiken
Erweiterte Notation EBNF
Backus Naur Form (BNF) erweitert um Konstrukte regulärer Ausdrücke zu Extended BNF
Eine kontext-freie Grammatik wurde 1959 erstmals zur Definition einer Programmiersprache
(Algol 60) verwendet. Name für die Notation - noch heute: Backus Naur Form (BNF).
EBNF
Entweder werden Symbolnamen gekennzeichnet,
z. B. durch Klammerung <Expr> oder durch den Schrifttyp Expr.
oder unbenannte Terminale, die für sich stehen, werden gekennzeichnet, z. B. '('
Zusammenfassung von Produktionen
mit gleicher linker Seite:
'(' Expr ')'
Ident
X ::= u (v) w
Klammerung
X ::= u Y w
Y ::= v
X ::= u [v] w
optional
X ::= u Y w
Y ::= v
Y ::= ε
X ::= u s* w
X ::= u { s } w
optionale
Wiederholung
X ::= u Y w
Y ::= s Y
Y ::= ε
X ::= u s ... w
X ::= u s+ w
Wiederholung
X ::= u Y w
Y ::= s Y
Y ::= s
X ::= u (v || s) w
Wdh. mit Trenner
X ::= u Y w
Y ::= v s Y
Y ::= v
X ::= u (v1 | v2) w
Alternativen
X ::= u Y w
Y ::= v1
Y ::= v2
Dabei sind u, v, v1, v2, w ∈V* s ∈ V
X, Y ∈ N
Y ist ein Nichtterminal, das sonst nicht in der Grammatik vorkommt.
© 2014 bei Prof. Dr. Uwe Kastens
::=
|
© 2005 bei Prof. Dr. Uwe Kastens
Opd
oder im Java -Manual:
Opd:
( Expr )
Ident
gleichbedeutende BNF-Produktionen
Beispiele:
Block ::= '{' Statement* '}'
Block ::= '{' Y '}'
Y ::= Statement Y
Y ::= ε
Decl ::= Type (Ident || ',') ';'
Decl ::= Type Y ';'
Y ::= Ident ',' Y
Y ::= Ident
GPS-2-13
GPS-2-14
Syntaxdiagramme
Expr:
Produktionen-Schemata für Folgen
Ein Syntaxdiagramm
repräsentiert eine
EBNF-Produktion:
+
Fact
Expr
Expr ::= [ Expr ( '+' | '-')] Fact
Option und Alternative
-
Expr ::= (Fact || ( '+' | '-'))
Expr:
© 2010 bei Prof. Dr. Uwe Kastens
Fact
+
Terminal:
-
Nichtterminal:
+
Fact
© 2014 bei Prof. Dr. Uwe Kastens
Wiederholung mit
alternativem Trenner
Beschreibung
Produktionen
Sprachmenge
nicht-leere Folge von b
A ::= A b | b
{b, bb, bbb, ...}
nicht-leere Folge von b
A ::= b A | b
{b, bb, bbb, ...}
evtl. leere Folge von b
A ::= A b |
{ε, b, bb, bbb, ...}
evtl. leere Folge von b
A ::= b A |
{ε, b, bb, bbb, ...}
nicht-leere Folge von b
getrennt durch t
A ::= A t b | b
{b, btb, btbtb, ...}
nicht-leere Folge von b
getrennt durch t
A ::= b t A | b
{b, btb, btbtb, ...}
GPS-2-15
GPS-2-14a
Grammatik-Entwurf: Folgen
Grammatik-Entwurf: Klammern
Klammern: Paar von Terminalen, das eine Unterstruktur einschließt:
Produktionen für Folgen von Sprachkonstrukten systematisch konstruieren.
Schemata hier am Beispiel von Anweisungsfolgen (Stmts)
Folgen mit Trenner:
a. Stmts
::=
b. Stmts
::=
c. Stmts
::=
d. StmtsOpt::=
Stmts ';' Stmt | Stmt
Stmt ';' Stmts | Stmt
( Stmt || ';')
Stmts |
Operand ::=
Stmt
::=
Stmt
::=
linksrekursiv
rechtsrekursiv
EBNF
mit leerer Folge
MethodenDef ::=
ErgebnisTyp MethodenName '(' FormaleParameter ')' Rumpf
Stilregel: Öffnende und schließende Klammer immer in derselben Produktion
gut :
b. Stmts
Stmt
c. Stmts
Stmt
::=
::=
::=
::=
Stmt
Stmts | Stmt
Assign ';' | ...
Stmts Stmt| Stmt
Assign ';' | ...
d. Stmts
::=
( Stmt ';')+
'while' Expr 'do' Stmts 'end'
Nicht-geklammerte (offene) Konstrukte können Mehrdeutigkeiten verursachen:
Stmt
::= 'if' Expr 'then' Stmt
|
'if' Expr 'then' Stmts 'else' Stmt
linksrekursiv
EBNF
Stmt ::=
schlecht: Stmt
::= WhileKopf Stmts 'end'
WhileKopf ::= 'while' Expr 'do'
rechtsrekursiv
Terminator an den Elementen
© 2015 bei Prof. Dr. Uwe Kastens
© 2014 bei Prof. Dr. Uwe Kastens
Folgen mit Terminator:
a. Stmts
::= Stmt ';' Stmts | Stmt ';'
'(' Expression ')'
'while' Expr 'do' Stmts 'end'
'while' Expr 'do' Stmts 'end'
Offener, optionaler else-Teil verursacht Mehrdeutigkeit in C, C++, Pascal,
sog. "dangling else"-Problem:
if c then if d then S1 else S2
In diesen Sprachen gehört else S2 zur inneren if-Anweisung.
Java enthält das gleiche if-Konstrukt. Die Grammatik vermeidet die Mehrdeutigkeit durch Produktionen, die die
Bindung des else explizit machen.
GPS-2-16
GPS-2-17
Abstrakte Syntax
KFG definiert
Symbolfolgen (Programmtexte) und
deren Ableitungsbäume
KFG definiert
abstrakte Programmstruktur durch
Strukturbäume
konkrete Syntax bestimmt die Struktur
von Programmkonstrukten, z. B.
Präzedenz und Assozitivität von
Operatoren in Ausdrücken
statische und dynamische Semantik
werden auf der abstrakten Syntax definiert
Präzedenzschemata benötigen
Kettenproduktionen, d.h. Produktionen
mit genau einem Nichtterminal auf der
rechtenSeite:
Expr ::= Fact
Fact ::= Opd
Opd ::= '(' Expr ')'
© 2010 bei Prof. Dr. Uwe Kastens
abstrakte Syntax
Mehrdeutigkeit ist problematisch
Alle Terminale sind nötig.
solche Kettenproduktionen sind hier
überflüssig
Mehrdeutigkeit ist akzeptabel
Terminale, die nur für sich selbst stehen
und keine Information tragen, sind hier
überflüssig (Wortsymbole, Spezialsymbole), z.B.
class ( ) + - * /
© 2010 bei Prof. Dr. Uwe Kastens
konkrete Syntax
Abstrakte Ausdrucksgrammatik
abstrakte Ausdrucksgrammatik
konkrete Ausdrucksgrammatik
Produktion
p1:
Expr
::= Expr AddOpr Fact Name
p2:
Expr
::= Fact
BinEx:
Exp
::= Exp BinOpr Exp
p3:
Fact
::= Fact MulOpr Opd IdEx:
Exp
::= Ident
p4:
Fact
::= Opd
PlusOpr: BinOpr ::=
p5:
Opd
::= '(' Expr ')'
MinusOpr: BinOpr ::=
p6:
Opd
::= Ident
TimesOpr: BinOpr ::=
p7:
AddOpr ::= '+'
DivOpr:
BinOpr ::=
p8:
AddOpr ::= '-'
p9:
MulOpr ::= '*'
p10: MulOpr ::= '/'
Strukturbaum für a * (b + c)
Exp
Abbildung
BinEx
konkret -> abstrakt
Exp
Exp
BinOpr
Expr,Fact,Opd -> Exp
BinEx
IdEx
TimesOpr
AddOpr,MulOpr -> BinOpr
Exp
BinOpr
Exp
Ident
p1,p3 -> BinEx
IdEx
IdEx
p2,p4,p5 ->
PlusOpr
Ident
Ident
p6 -> IdEx
*
b
+
a
p7 -> PlusOpr
c
...
GPS-2.19
GPS-2.19a
2.3 XML
Übersicht
3 elementare Prinzipien
Die XML-Notation basiert auf 3 elementaren
Prinzipien:
XML (Extensible Markup Language, dt.: Erweiterbare Auszeichnungssprache)
• seit 1996 vom W3C definiert, in Anlehnung an SGML
A: Vollständige Klammerung durch Tags
• Zweck: Beschreibungen allgemeiner Strukturen (nicht nur Web-Dokumente)
• Meta-Sprache (“erweiterbar”):
Die Notation ist festgelegt (Tags und Attribute, wie in HTML),
Für beliebige Zwecke kann jeweils eine spezielle syntaktische Struktur definiert
werden (DTD)
Außerdem gibt es Regeln (XML-Namensräume), um XML-Sprachen in andere
XML-Sprachen zu importieren
<a>
<b>Hello</b>
<c>World</c>
</a>
a
B: Klammerstruktur ist äquivalent zu
gewurzeltem Baum
• XHTML ist so als XML-Sprache definiert
b
c
Hello
World
• Weitere aus XML abgeleitete Sprachen: SVG, MathML, SMIL, RDF, WML
• individuelle XML-Sprachen werden benutzt, um strukturierte Daten zu speichern,
C: Kontextfreie Grammatik definiert Bäume;
eine DTD ist eine KFG
• XML-Darstellung von strukturierten Daten kann mit verschiedenen Techniken in
HTML transformiert werden, um sie formatiert anzuzeigen:
XML+CSS, XML+XSL, SAX-Parser, DOM-Parser
Dieser Abschnitt orientiert sich eng an SELFHTML (Stefan Münz), http://de.selfhtml.org
S
GPS-2.20
GPS-2.21
Notation und erste Beispiele
Ein vollständiges Beispiel
Ein Satz in einer XML-Sprache ist ein Text, der durch Tags strukturiert wird.
Kennzeichnung des
Dokumentes als XML-Datei
Tags werden immer in Paaren von Anfangs- und End-Tag verwendet:
<ort>Paderborn</ort>
Anfangs-Tags können Attribut-Wert-Paare enthalten:
<telefon typ="dienst">05251606686</telefon>
(a+b)2 in MathML:
© 2005 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
Mit Tags gekennzeichnete Texte können geschachtelt werden.
<msup>
<mfenced>
<mrow>
<mi>a</mi>
<mo>+</mo>
<mi>b</mi>
</mrow>
</mfenced>
<mn>2</mn>
</msup>
Datei mit der Definition der
Syntaktischen Struktur dieser
XML-Sprache (DTD)
Datei mit Angaben zur
Transformation in HTML
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE produktnews SYSTEM "produktnews.dtd">
<?xml-stylesheet type="text/xsl" href="produktnews.xsl" ?>
Die Namen von Tags und Attributen können für die XML-Sprache frei gewählt werden.
<adressBuch>
<adresse>
<name>
<nachname>Mustermann</nachname>
<vorname>Max</vorname>
</name>
<anschrift>
<strasse>Hauptstr 42</strasse>
<ort>Paderborn</ort>
<plz>33098</plz>
</anschrift>
</adresse>
</adressBuch>
a ::= b c
b ::= PCDATA
c ::= PCDATA
© 2010 bei Prof. Dr. Uwe Kastens
© 2009 bei Prof. Dr. Uwe Kastens
die von Software-Werkzeugen geschrieben und gelesen werden
<produktnews>
Die neuesten Produktnachrichten:
<beschreibung>
Die Firma <hersteller>Fridolin Soft</hersteller> hat eine neue
Version des beliebten Ballerspiels
<produkt>HitYourStick</produkt> herausgebracht. Nach Angaben des
Herstellers soll die neue Version, die nun auch auf dem
Betriebssystem <produkt>Ganzfix</produkt> läuft, um die
<preis>80 Dollar</preis> kosten.
</beschreibung>
<beschreibung>
Von <hersteller>Ripfiles Inc.</hersteller> gibt es ein Patch zu der Sammel-CD
<produkt>Best of other people’s ideas</produkt>. Einige der tollen
Webseiten-Templates der CD enthielten bekanntlich noch versehentlich nicht
gelöschte Angaben der Original-Autoren. Das Patch ist für schlappe
<preis>200 Euro</preis> zu haben.
</beschreibung>
</produktnews>
GPS-2.22
GPS-2.23
Grammatik definiert die Struktur der XML-Bäume
Jeder XML-Text ist durch Tag-Paare vollständig geklammert (wenn er well-formed ist).
Mit kontextfreien Grammatiken (KFG) kann man Bäume definieren.
Deshalb kann er eindeutig als Baum dargestellt werden. (Attribute betrachten wir noch nicht)
Wir markieren die inneren Knoten mit den Tag-Namen; die Blätter sind die elementaren Texte:
Folgende KFG definiert korrekt strukturierte Bäume für das Beispiel Adressbuch:
<adressBuch>
<adresse>
<name>
<nachname>Mustermann
</nachname>
<vorname>Max
</vorname>
</name>
<anschrift>
<strasse>Hauptstr 42
</strasse>
<ort>Paderborn</ort>
<plz>33098</plz>
</anschrift>
</adresse>
</adressBuch>
adressBuch ::= adresse*
adressBuch
adressBuch
adresse
::= name anschrift
name
::= nachname vorname
adresse
name
name
Anschrift ::= strasse ort plz
nachname
Mustermann
adresse
anschrift
vorname
Max
nachname
::= PCDATA
vorname
::= PCDATA
strasse
::= PCDATA
ort
::= PCDATA
plz
::= PCDATA
nachname
Mustermann
vorname
ort
Hauptstr 42
plz
Paderborn
33098
XML-Werkzeuge können die Baumstruktur eines XML-Textes
ohne weiteres ermitteln und ggf. anzeigen.
anschrift
Max
strasse
© 2010 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
Baumdarstellung von XML-Texten
strasse
ort
Hauptstr 42
plz
Paderborn
33098
GPS-2.24
GPS-2-31
Document Type Definition (DTD) statt KFG
Zusammenfassung zu Kapitel 2
Die Struktur von XML-Bäumen und -Texten wird in der DTD-Notation definiert. Ihre Konzepte
entsprechen denen von KFGn:
KFG
adressBuch ::= adresse*
adresse
::= name anschrift
name
::= nachname vorname
Anschrift ::= strasse ort plz
nachname
::= PCDATA
vorname
::= PCDATA
strasse
::= PCDATA
ort
::= PCDATA
plz
::= PCDATA
Mit den Vorlesungen und Übungen zu Kapitel 2 sollen Sie nun Folgendes können:
DTD
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
adressBuch(adresse)*
>
adresse
(name, anschrift) >
name
(nachname, vorname)>
anschrift (strasse, ort, plz)>
nachname (#PCDATA)
>
vorname
(#PCDATA)
>
strasse
(#PCDATA)
>
ort
(#PCDATA)
>
plz
(#PCDATA)
>
• Notation und Rolle der Grundsymbole kennen.
• Kontext-freie Grammatiken für praktische Sprachen lesen und verstehen.
• Kontext-freie Grammatiken für einfache Strukturen selbst entwerfen.
• Schemata für Ausdrucksgrammatiken, Folgen und Anweisungsformen anwenden
können.
• EBNF sinnvoll einsetzen können.
• Abstrakte Syntax als Definition von Strukturbäumen verstehen.
X (Y)+
nicht-leere Folge
X (A | B)
Alternative
X (A)?
Option
X EMPTY
leeres Element
• XML als Meta-Sprache zur Beschreibung von Bäumen verstehen
• DTD von XML als kontext-freie Grammatik verstehen
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
weitere Formen von DTD-Produktionen:
• XML lesen können
GPS-3-1
GPS-3-2
3. Gültigkeit von Definitionen
Definition und Bindung
Themen dieses Kapitels:
Eine Definition ist ein Programmkonstrukt, das die Beschreibung eines
Programmgegenstandes an einen Bezeichner bindet.
• Definition und Bindung von Bezeichnern
Programmkonstrukt: zusammengehöriger Teil (Teilbaum) eines Programms
z. B. eine Deklaration int i;, eine Anweisung i = 42; Ausdruck i+1
• Verdeckungsregeln für die Gültigkeit von Definitionen
Programmgegenstand: wird im Programm beschrieben und benutzt
z. B. die Methode main, der Typ String, eine Variable i, ein Parameter args
• Gültigkeitsregeln in Programmiersprachen
Meist legt die Definition Eigenschaften des Programmgegenstandes fest,
z. B. den Typ:
© 2010 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
public static void main (String[] args)
GPS-3-2a
GPS-3-3
Statische und dynamische Bindung
Gültigkeitsbereich
Ein Bezeichner, der in einer Definition gebunden wird, tritt dort definierend auf;
an anderen Stellen tritt er angewandt auf.
Definierendes und angewandtes Auftreten von Bezeichnern kann man meist
syntaktisch unterscheiden, z. B.
Der Gültigkeitsbereich (scope) einer Definition D für einen Bezeichner b ist der
Programmabschnitt, in dem angewandte Auftreten von b an den in D definierten Programmgegenstand gebunden sind.
{ def a;
def b;
{ def a;
def c;
use a;
}
use a;
}
static int ggt (int a, int b)
{ ...
return ggt(a % b, b);
...
}
© 2010 bei Prof. Dr. Uwe Kastens
Statische Bindung:
Gültigkeitsregeln entscheiden die Bindung am
Programmtext, z. B.
{ float a = 1.0;
{ int a = 2;
printf ("%d",a);
}
}
statische Bindung im Rest dieses Kapitels und
in den meisten Sprachen, außer ...
Dynamische Bindung:
Wird bei der Ausführung des
Programms entschieden:
Für einen angewandten Bezeichner
a gilt die zuletzt für a ausgeführte
Definition.
dynamische Bindung
in Lisp und einigen Skriptsprachen
© 2005 bei Prof. Dr. Uwe Kastens
Regeln der Sprache entscheiden, in welcher Definition ein
angewandtes Auftreten eines Bezeichners gebunden ist.
Gültigkeitsbereiche
äußeres a
inneres a
äußeres a
In qualifizierten Namen, können Bezeichner auch außerhalb des Gültigkeitsbereiches ihrer
Definition angewandt werden:
Thread.sleep(1000); max = super.MAX_THINGS;
sleep ist in der Klasse Thread definiert, MAX_THINGS in einer Oberklasse.
GPS-3-4
GPS-3-5
Verdeckung von Definitionen
Beispiele für Gültigkeitsbereiche
In Sprachen mit geschachtelten Programmstrukturen kann eine Definition eine andere
für den gleichen Bezeichner verdecken (hiding).
Symbole:
Algol-Regel
a1
a2
a3
Es gibt 2 unterschiedliche Grundregeln dafür:
a
Algol-Verdeckungsregel (in Algol-60, Algol-68, Pascal, Modula-2, Ada, Java s. u.):
a
a
Eine Definition gilt im kleinsten sie umfassenden Abschnitt überall, ausgenommen
darin enthaltene Abschnitte mit einer Definition für denselben Bezeichner.
Definition
Anwendung
Algol-Regel
a
a
oder operational formuliert:
Suche vom angewandten Auftreten eines Bezeichners b ausgehend nach außen den
kleinsten umfassenden Abschnitt mit einer Definition für b.
p1
p2
Die Algol-Regel ist einfacher, toleranter und vermeidet Sonderregeln für notwendige
Vorwärtsreferenzen.
a
© 2014 bei Prof. Dr. Uwe Kastens
Die C-Regel erzwingt definierendes vor angewandtem Auftreten.
p
a
Die Definition eines Bezeichners b gilt von der Definitionsstelle bis zum Ende des
kleinsten sie umfassenden Abschnitts, ausgenommen die Gültigkeitsbereiche von
Definitionen für b in darin enthaltenen Abschnitten.
C-Regel
p1
p2
p
a
C-Verdeckungsregel (in C, C++, Java):
© 2010 bei Prof. Dr. Uwe Kastens
Abschnitt
hier gilt
noch
das
äußere
p!
p
a
p
GPS-3-6
GPS-3-6a
Getrennte Namensräume
Gültigkeitsbereiche in Java
In manchen Sprachen werden die Bezeichner für Programmgegenstände
bestimmter Art jeweils einem Namensraum zugeordnet
Package-Namen:
sichtbare Übersetzungseinheiten
z. B. in Java jeweils ein Namensraum für
Typnamen:
in der ganzen Übersetzungseinheit, Algol-60-Verdeckungsregel
• Packages, Typen (Klassen und Interfaces), Variable (lokale Variable,
Parameter, Objekt- und Klassenvariable), Methoden, Anweisungsmarken
Methodennamen:
umgebende Klasse, Algol-60-Verdeckungsregel, aber
Objektmethoden der Oberklassen werden überschrieben oder überladen - nicht verdeckt
Gültigkeits- und Verdeckungsregeln werden nur innerhab eines
Namensraumes angewandt - nicht zwischen verschiedenen Namensräumen.
class Multi {
Eine
Multi () { Multi = 5;}
Klassendeklaration
private int Multi;
nur für Zwecke der
Multi Multi (Multi Multi) {
Demonstration:
if (Multi == null)
return new Multi();
else return Multi (new Multi ());
}
}
Namen von Objekt- und Klassenvariablen:
umgebende Klasse, Algol-60-Verdeckungsregel,
Objekt- und Klassenvariable können Variable der Oberklassen verdecken
Parameter:
Methodenrumpf, (dürfen nur durch innere Klassen verdeckt werden)
Typ
Variable
Methode
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
Zu welchem Namensraum ein Bezeichner gehört, kann am syntaktischen
Kontext erkannt werden. (In Java mit einigen zusätzlichen Regeln)
Lokale Variable:
Rest des Blockes (bzw. bei Laufvariable in for-Schleife: Rest der for-Schleife),
C-Verdeckungsregel (dürfen nur durch innere Klassen verdeckt werden)
Terminologie in Java:
shadowing für verdecken bei Schachtelung, hiding für verdecken beim Erben
GPS-3.6aa
GPS-3.6ab
Beispiele für Gültigkeitsbereiche in Java
© 2005 bei Prof. Dr. Uwe Kastens
class A
{
void m (int p)
{ cnt += 1;
float f;
...
}
B mm ()
{ return new B();
}
int cnt = 42;
}
class Ober
{ int k;
...
}
char int
x
x
class Unter extends Ober
{ int k;
void m ()
{ k = 5;
}
void g (int p)
{ int k = 7;
k = 42;
for ( int i = 0;
i<10; i++)
{
int k; // verboten
...
}
class B
{
...
}
}
}
float
x
class A
{ char x;
void m ()
{ int x;
class B
{
void h ()
{ float x;
...
}
Innere Klasse B:
Lokale Variable float x in h
verdeckt
lokale Variable int x in m
der äußeren Klasse
}
...
© 2011 bei Prof. Dr. Uwe Kastens
A B m mm cnt p f
Innere Klassen in Java: Verdeckung von lokalen Variablen
}
...
}
GPS-3-6b
GPS-3-7
Gültigkeitsregeln in anderen Programmiersprachen
C, C++:
grundsätzlich gilt die C-Regel;
für Sprungmarken gilt die Algol-Regel.
Zusammenfassung zum Kapitel 3
void f () {
...
goto finish;
...
finish: printf (...);
}
Pascal, Ada, Modula-2:
grundsätzlich gilt die Algol-Regel.
Aber eine Zusatzregel fordert:
Mit den Vorlesungen und Übungen zu Kapitel 3 sollen Sie nun Folgendes
können:
• Bindung von Bezeichnern verstehen
• Verdeckungsregeln für die Gültigkeit von Definitionen anwenden
Ein angewandtes Auftreten eines Bezeichners darf nicht vor seiner Definition stehen.
• Grundbegriffe in den Gültigkeitsregeln von Programmiersprachen erkennen
Davon gibt es dann in den Sprachen unterschiedliche Ausnahmen, um wechselweise
rekursive Definitionen von Funktionen und Typen zu ermöglichen.
C:
typedef struct _el *ListPtr;
typedef struct _el
{ int i; ListPtr n;} Elem;
Pascal:
procedure f (a:real) forward;
procedure g (b:real)
begin ... f(3.5); ... end;
procedure f (a:real)
begin ... g(7.5); ... end;
© 2005 bei Prof. Dr. Uwe Kastens
© 2012 bei Prof. Dr. Uwe Kastens
Pascal:
type ListPtr = ^ List;
List = record
i: integer;
n: ListPtr
end;
GPS-4-1
GPS-4-2
4. Variable, Lebensdauer
Variable in imperativen Sprachen
Themen dieses Kapitels:
Variable: wird im Programm beschrieben, z. B. durch Deklaration (statisch),
wird bei der Ausführung im Speicher erzeugt und verwendet (dynamisch),
wird charakterisiert durch das Tripel (Name, Speicherstelle, Wert).
• Variablenbegriff und Zuweisung
Einem Namen im Programm werden (bei der Ausführung) eine oder mehrere Stellen im
Speicher zugeordnet.
• unterschiedliche Lebensdauer von Variablen
Das Ausführen von Zuweisungen ändert den Wert der Variablen (Inhalt der Speicherstelle).
Bei der Ausführung eines imperativen Programms wird so der Programmzustand verändert.
• Laufzeitkeller als Speicherstruktur für Variablen in Aufrufen
Der Deklaration einer globalen (static) Variable ist genau eine Stelle zugeordnet.
Der Deklaration einer lokalen Variablen einer Funktion wird bei jeder Ausführung eines
Aufrufes eine neue Stelle zugeordnet.
© 2010 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
im Programm:
im Speicher bei der Ausführung:
int betrag = 0;
...
betrag = 50;
β
Speicherstelle β
50 0
GPS-4-2a
GPS-4-3
Veränderliche und unveränderliche Variable
In imperativen Sprachen kann der Wert einer
Variablen grundsätzlich durch Ausführen von
Zuweisungen verändert werden.
In manchen imperativen Sprachen, wie Java,
kann für bestimmte Variable verboten werden,
nach ihrer Initialisierung an sie zuzuweisen.
In funktionalen Sprachen wird bei der
Erzeugung einer Variablen ihr Wert
unveränderlich festgelegt.
Zuweisung
Zuweisung: LinkeSeite = RechteSeite;
int betrag = 0;
...
betrag = 50;
im Programm:
Ausführen einer Zuweisung:
1. Auswerten der linken Seite;
muss die Stelle einer Variablen liefern.
final int hekto = 100;
2. Auswerten der rechten Seite
liefert einen Wert.
In Ausdrücken stehen Namen von
Variablen für ihren Wert, d. h. es wird
implizit eine Inhaltsoperation
ausgeführt.
val sechzehn = (sqr 4);
∀ x, y ∈ ℜ: y = 2 * x - 1
definiert eine Gerade im ℜ2
© 2010 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
3. Der Wert der Variablen aus (1) wird
durch den Wert aus (2) ersetzt.
In mathematischen Formeln wird ein Wert
unveränderlich an den Namen einer
Variablen gebunden. (Die Formel kann mit
verschiedenen solchen Name-Wert-Bindungen
ausgewertet werden.)
Beispiel
b = 42;
c = b + 1;
i = 3;
a[i] = c;
im Speicher:
Speicherstelle zu
b
c
i
a
42
43
3
a[3]
43
GPS-4-3a
GPS-4-4
Stellen als Werte von Variablen
Java:
Circles cir =
new Circles(0, 1.0);
x = cir.getRadius();
Art der Variablen
Lebensdauer ist die Ausführung ...
C++:
Circles *cir =
new Circles(0, 1.0);
x = cir->getRadius();
Unterbringung im
Speicher
globale Variable
Klassenvariable
... des gesamten Programms
globaler Speicher
Parametervariable,
lokale Variable
... eines Aufrufes
Laufzeitkeller
C:
Objektvariable
... des Programms von der Erzeugung
bis zur Vernichtung des Objekts
Halde, ggf. mit
Speicherbereinigung
In C können Pointer-Variable Stellen als
Werte haben (wie in C++). Die Ausführung
von malloc (sizeof(Circles)) liefert
die Stelle (Referenz) eines im Speicher
erzeugten Objektes.
© 2014 bei Prof. Dr. Uwe Kastens
Lebensdauer von Variablen im Speicher
Lebensdauer: Zeit von der Bildung (Allokation) bis zur Vernichtung (Deallokation) des
Speichers einer Variablen. Begriff der dynamischen Semantik!
Der Ausdruck &i liefert die Stelle der
deklarierten Variable i, d. h. der &-Operator
unterdrückt die implizite Inhaltsoperation.
Der Ausdruck *i bewirkt eine Inhaltsoperation - zusätzlich zu der impliziten.
Circles *cir =
malloc(sizeof(Circle));
cir->radius = 1.0;
Variable mit gleicher Lebensdauer werden zu Speicherblöcken zusammengefasst. (Bei
Sprachen mit geschachtelten Funktionen kommen auch Funktionsrepräsentanten dazu.)
Speicherblock für
int
int
j =
p =
i = 5, j = 0;
*p = &i;
*p + 1;
&i;
© 2010 bei Prof. Dr. Uwe Kastens
In objektorientierten Sprachen, wie Java oder
C++, liefert die Ausführung von new C(...)
die Stelle (Referenz) eines im Speicher
erzeugten Objektes. Sie kann in Variablen
gespeichert werden.
• Klassenvariable einer Klasse
• einen Aufruf mit den Parametervariablen und lokalen Variablen
• ein Objekt einer Klasse mit seinen Objektvariablen
GPS-4-5
GPS-4-6
Laufzeitkeller
Laufzeitkeller bei geschachtelten Funktionen
Der Laufzeitkeller enthält für jeden noch nicht beendeten Aufruf einen Speicherblock
(Schachtel, activation record) mit Speicher für Parametervariable und lokale Variable.
Bei Aufruf wird eine Schachtel gekellert, bei Beenden des Aufrufes entkellert.
Programm mit Funktionen (Methoden)
h float a;
Bei der Auswertung von Ausdrücken kann auf Variablen aus der Umgebung zugegriffen
werden. Das sind die Speicherblöcke zu den Programmstrukturen, die den Ausdruck umfassen.
in Pascal, Modula-2, in funktionalen Sprachen: geschachtelte Funktionen
in Java: Methoden in Klassen, geschachtelte Klassen
Laufzeitkeller bei der
Im Laufzeitkeller wird die aktuelle Umgebung repräsentiert durch die aktuelle Schachtel und
die Schachteln entlang der Kette der statischen Vorgänger. Der statische Vorgänger zeigt auf
die Schachtel, die die Definition der aufgerufenen Funktion enthält.
Aufruffolge h, q, q, q, r
h a:
q();
h
q i:
Programm mit
geschachtelten
Funktionen
q
r
q i:
b:
b=...
b=...;
kellern, entkellern
int i;
r
q i:
r
int b;
q
int b;
b=i+1;
© 2015 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
int i;
if (..) q();
r();
Laufzeitkeller bei
Aufruf von r
h a:
q:
float a;
if(..) q();
r();
q();
kellern, entkellern
q i:
r:
q i:
r:
q i:
r:
b:
r
b=i+1;
statischer
Vorgänger
GPS-4-7
GPS-5-1
Zusammenfassung zum Kapitel 4
5. Datentypen
Mit den Vorlesungen und Übungen zu Kapitel 4 sollen Sie nun Folgendes
verstanden haben:
Themen dieses Kapitels:
• Variablenbegriff und Zuweisung
• Typbindung, Typumwandlung
• Zusammenhang zwischen Lebensdauer von Variablen und ihrer Speicherung
• abstrakte Definition von Typen
• Prinzip des Laufzeitkellers
• parametrisierte und generische Typen
5.1 Allgemeine Begriffe zu Datentypen
• Besonderheiten des Laufzeitkellers bei geschachtelten Funktionen
5.2 Datentypen in Programmiersprachen
• einfache Typen, Verbunde, Vereinigungstypen, Reihungen
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
• Funktionen, Mengen, Stellen
GPS-5-2
GPS-5-2a
5.1 Allgemeine Begriffe zu Typen
Statische oder dynamische Typbindung
Typ: Wertemenge mit darauf definierten Operationen
z. B. int in Java: Werte von Integer.MIN_VALUE bis Integer.MAX_VALUE
mit arithmetischen Operationen für ganze Zahlen
Statische Typbindung:
Die Typen von Programmgegenständen (z.B. Variable, Funktionen) und Programmkonstrukten (z. B. Ausdrücke, Aufrufe) werden durch den Programmtext festgelegt.
Typ als Eigenschaft von
Literal:
Notation für einen Wert des Typs,
Variable:
speichert einen Wert des Typs,
Parameter:
übergibt einen Wert des Typs an den Aufruf,
Ausdruck:
Auswertung liefert einen Wert des Typs,
Aufruf:
Auswertung liefert einen Wert des Typs,
Funktion, Operator: Signatur (Parameter- und Ergebnistypen)
z. B. in Java, Pascal, C, C++, Ada, Modula-2 explizit durch Deklarationen
z. B. in SML, Haskell implizit durch Typinferenz (siehe GPS-7.4 ff)
Typprüfung im Wesentlichen zur Übersetzungszeit.
Entwickler muss erkannte Typfehler beheben.
Dynamische Typbindung:
Die Typen der Programmgegenstände und Programmkonstrukte werden erst
bei der Ausführung bestimmt. Sie können bei der Ausführung nacheinander
Werte unterschiedlichen Typs haben.
Typen werden in der Sprache definiert:
z. B. in C: int, float, char, ...
z. B. Smalltalk, PHP, JavaScript und andere Skriptsprachen
Typprüfung (type checking):
stellt sicher, dass jede Operation mit Werten des dafür festgelegten Typs ausgeführt wird,
Typsicherheit
Typprüfung erst zur Laufzeit.
Evtl. werden Typfehler erst beim Anwender erkannt.
© 2009 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
Typen können in Programmen definiert werden:
Typdefinition bindet die Beschreibung eines Typs an einen Namen,
z. B. in Pascal:
type Datum = record tag, monat, jahr: integer; end;
Keine Typisierung:
In den Regeln der Sprache wird der Typbegriff nicht verwendet.
z. B. Prolog, Lisp
GPS-5-2b
GPS-5-3
Beispiele für statische Typregeln
Streng typisiert
Streng typisierte Sprachen (strongly typed languages):
1. Eine Variable mit Typ T kann nur einen Wert aus der Wertemenge von T speichern.
float x; ... x = r * 3.14;
Die Einhaltung der Typregeln der Sprache stellt sicher, dass jede Operation
nur mit Werten des dafür vorgesehenen Typs ausgeführt wird.
2. Der Ausdruck einer return-Anweisung muss einen Wert liefern, der aus der
Wertemenge des Ergebnistyps der umgebenden Funktion ist (oder in einen solchen
Wert konvertiert werden kann (siehe GPS-5.4)).
float sqr (int i) {return i * i;}
Jede Verletzung einer Typregel wird erkannt und als Typfehler gemeldet
- zur Übersetzungszeit oder zur Laufzeit.
3. Im Aufruf einer Funktion muss die Zahl der Parameterausdrücke mit der Zahl der
formalen Parameter der Funktionsdefinition übereinstimmen und jeder Parameterausdruck muss einen Wert liefern, der aus der Wertemenge des Typs des
zugehörigen formalen Parameters ist (oder ... s.o.)).
nicht streng typisiert
Parameter werden nicht geprüft
Pascal
nicht ganz streng typisiert Typ-Uminterpretation in Variant-Records
C, C++
nicht ganz streng typisiert es gibt undiscriminated Union-Types
Ada
nicht ganz streng typisiert es gibt Direktiven, welche die Typprüfung an
bestimmten Stellen ausschalten
Java
streng typisiert
alle Typfehler werden entdeckt,
zum Teil erst zur Laufzeit
© 2009 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
4. Zwei Methoden, die in einer Klasse deklariert sind und denselben Namen haben,
überladen einander, wenn sie in einigen Parameterpositionen unterschiedliche
Typen haben. Z. B.
int add (int a, int b) { return a + b; }
Vector<Integer> add (Vector<Integer> a, Vector<Integer> b) {...}
FORTRAN
In einem Aufruf einer überladenen Methode wird anhand der Typen der Parameterausdrücke entschieden, welche Methode aufgerufen wird:
int k; ... k = add (k, 42);
GPS-5-4
GPS-5-4a
Typumwandlung (Konversion)
Explizite und implizite Typumwandlung
Eine Konversion kann explizit im Programm als Operation angegeben werden
(type cast), z. B.
float x = 3.1; int i = (int) x;
Typumwandlung, Konversion (conversion):
Der Wert eines Typs wird in einen entsprechenden Wert eines anderen Typs
umgewandelt.
Eine Konversion kann implizit vom Übersetzer eingefügt werden (coercion),
weil der Kontext es erfordert, z. B.
double d = 3.1;
implizit float --> double
d = d + 1;
implizit int --> double
ausweitende Konversion:
jeder Wert ist im Zieltyp ohne Informationsverlust darstellbar, z. B.
float --> double
einengende Konversion:
nicht jeder Wert ist im Zieltyp darstellbar, ggf. Laufzeitfehler, z. B.
float --> int
Java: ausweitende Konversionen für Grund- und Referenztypen implizit,
einengende müssen explizit angegeben werden.
(Runden, Abschneiden oder Überlauf)
Uminterpretation ist unsicher, ist nicht Konversion!:
Das Bitmuster eines Wertes wird als Wert eines anderen Typs interpretiert.
z. B. Varianten-Records in Pascal (GPS-5.14)
© 2010 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
Konversion für Referenzen ändert weder die Referenz noch das Objekt:
Object val = new Integer (42); implizit Integer --> Object
Integer ival = (Integer) val; explizit Object --> Integer
GPS-5-5
GPS-5-7
Abstrakte Definition von Typen
Abstrakte Definition von Typen: Beispiele
Datenstrukturen werden in Programmen mit Typen modelliert => Modellierungskonzepte
1. einfache Mengen:
Pascal:
C:
Abstrakte Grundkonzepte zur Bildung einfacher und zusammengesetzter Wertemengen D:
(Hier: nur Wertemengen der Typen; Operationen darauf werden davon nicht erfasst.)
1. einfache Mengen:
D = { e1, e2, ..., en }
D = {a | Eigenschaft von a}
z. B. Grundtypen, Aufzählungstypen, Auschnittstypen
2. kartesisches Produkt:
2. kartesisches Produkt: Graph = Knoten × Kanten
Pascal:
type Graph = record n: Knoten; v: Kanten end;
C:
typedef struct { Knoten n; Kanten v; } Graph;
extensionale Aufzählung
der Elemente
intensionale Definition
3. Vereinigung:
Pascal:
D = D1 × D2 × ... × Dn
Tupel z. B. Verbunde (records); Reihungen (arrays) (mit gleichen Di)
3. Vereinigung:
C:
D = D1 | D2 | ... | Dn
© 2005 bei Prof. Dr. Uwe Kastens
© 2009 bei Prof. Dr. Uwe Kastens
Alternativen zusammenfassen
z. B. union in C und Algol 68, Verbund-Varianten in Pascal, Ober-, Unterklassen
4. Funktion:
D = Dp -> De
Funktionen als Werte des Wertebreiches D
z. B. Funktionen, Prozeduren, Methoden, Operatoren; auch Reihungen (Arrays)
5. Potenzmenge:
D = Ρ ( De )
z. B. Mengentypen in Pascal
Farbe = {blau,gelb,rot}
type Farbe = (blau,gelb,rot);
typedef enum {blau,gelb,rot} Farbe;
Geo = Kreis | Rechteck
type Geo = record case boolean of
false: (k: Kreis);
true: (r: Rechteck)
end;
typedef union {Kreis k; Rechteck r} Geo;
IntOprSig = int × int -> int
4. Funktion:
Pascal:
C:
Funktionen nicht allgemein als Daten, nur als Parameter ohne Angabe der Signatur
5. Potenzmenge:
Pascal:
C:
Mischfarbe = Ρ ( Farbe )
type Mischfarbe = set of farbe;
typedef unsigned Mischfarbe;
typedef int IntOprSig(int,int);
GPS-5-8
GPS-5-8a
Kombination von Typen
Rekursive Definition von Typen
Die Grundkonzepte zur Typkonstruktion sind prinzipiell beliebig kombinierbar,
z. B. Kreise oder Rechtecke zusammengefasst zu 2-dimensionalen geometrischen Figuren:
Wertemengen können auch rekursiv definiert werden:
z. B. ein Typ für lineare Listen rekursiv definiert durch Paare:
IntList = int × IntList | {nil}
{nil} ist eine einelementige Wertemenge. nil repräsentiert hier die leere Liste.
Koord2D = float × float
Form = {istKreis, istRechteck}
Figur = Koord2D ×
Form ×
(float | float × float)
Position
Kennzeichen
Radius
Werte des Typs sind z. B.
nil, (1,nil), (2,nil),...,(1,(1,nil)), (8,(9,(4,nil))), ...
Kantenlängen
z. B. Signatur einer Funktion zur Berechnung von Nullstellen einer als Parameter gegebenen
Funktion:
Entsprechend für Bäume:
IntTree = IntTree × int × IntTree | {TreeNil}
(float −> float) × float × float -> P (float)
Funktion
Bereich
Eine rekursive Typdefinition ohne nicht-rekursive Alternative ist so nicht sinnvoll, da keine
Werte gebildet werden können:
X = int × X
Menge der Nullstellen
© 2008 bei Prof. Dr. Uwe Kastens
© 2008 bei Prof. Dr. Uwe Kastens
In funktionalen Sprachen können Typen direkt so rekursiv definiert werden, z. B. in SML:
datatype IntList = cons of (int × IntList) | IntNil;
In imperativen Sprachen werden rekursive Typen mit Verbunden (struct) implementiert, die
Verbundkomponenten mit Stellen als Werte (Pointer) enthalten, z. B. in C:
typedef struct _IntElem *IntList;
typedef struct _IntElem { int head; IntList tail;} IntElem;
GPS-5-9
GPS-5-9a
Parametrisierte Typen
Polymorphe Funktionen
Parametrisierte Typen (Polytypen):
Typangaben mit formalen Parametern, die für Typen stehen.
(Parametrisch) polymorphe Funktion:
eine Funktion, deren Signatur ein Polytyp ist, d. h. Typparameter enthält.
Man erhält aus einem Polytyp einen konkreten Typ durch konsistentes Einsetzen eines
beliebigen Typs für jeden Typparameter.
Die Funktion ist auf Werte eines jeden konkreten Typs zu der Signatur anwendbar.
D. h. sie muss unabhängig von den einzusetzenden Typen sein;
Ein Polytyp beschreibt die Typabstraktion, die allen daraus erzeugbaren konkreten Typen
gemeinsam ist.
Beispiele:
eine Funktion, die die Länge einer beliebigen homogenen Liste bestimmt:
fun length l = if null l then 0 else 1 + length (tl l);
Polytyp
gemeinsame Eigenschaften
konkrete Typen dazu
polymorphe Signatur:'a list -> int
'a × 'b
Paar mit Komponenten
beliebigen Typs
int × float
int × int
Aufrufe: length ([1, 2, 3]); length ([(1, true), (2, true)]);
'a × 'a
Paar mit Komponenten
gleichen Typs
int × int
(int−>float) × (int->float)
'a list = 'a × 'a list | {nil}
homogene, lineare Listen
eine Funktion, die aus einer Liste durch elementweise Abbildung eine neue Liste erzeugt:
fun map (f, l) = ...
int list
float list
(int × int) list
Verwendung z. B. in Typabstraktionen und in polymorphen Funktionen (GPS-5-9a)
In SML werden konkrete Typen zu parametrisierten Typen statisch bestimmt und geprüft.
© 2011 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
Beispiele in SML-Notation mit 'a, 'b, ... für Typparameter:
polymorphe Signatur: ((’a -> ’b) × ’a list) -> ’b list
Aufruf: map (even, [1, 2, 3]) liefert [false, true, false]
int->bool,int list
bool list
GPS-5-10
GPS-5-10j
Generische Definitionen
Generische Definitionen in C++
Generische Definitionen wurden in Ada und C++ schon früher als in Java eingeführt.
Außer Klassen können auch Module (Ada) und Funktionen generisch definiert werden.
Formale generische Parameter stehen für beliebige Typen, Funktionen oder Konstante.
(Einschränkungen können nicht formuliert werden.)
Eine Generische Definition hat formale generische Parameter.
Sie ist eine abstrakte Definition einer Klasse oder eines Interfaces.
Für jeden generischen Parameter kann ein Typ eingesetzt werden.
(Er kann auf Untertypen eines angegebenen Typs eingeschränkt werden.)
Beispiel in C++:
Generische Definition einer Klasse Stack mit generischem Parameter für den Elementtyp
Beispiel in Java:
Generische Definition einer Klasse Stack mit generischem Parameter für den Elementtyp
template <class Elem>
class Stack
{ private Elem store [size];
void push (Elem el) {... store[top]=el;...}
...
};
class Stack<Elem>
{ private Elem [] store ;
void push (Elem el) {... store[top]= el;...}
...
};
Eine generische Definition wird instanziiert durch Einsetzen von aktuellen generischen
Parametern. Dadurch entsteht zur Übersetzungszeit eine Klassendefinition. Z. B.
Eine generische Definition wird instanziiert durch Einsetzen von aktuellen generischen
Parametern. Dadurch entsteht Übersetzungszeit eine Klassen-, Modul- oder
Funktionsdefinition.
Generische Instanziierung kann im Prinzip durch Textersetzung erklärt werden: Kopieren
der generischen Definition mit Einsetzen der generischen Parameter im Programmtext.
Der Java-Übersetzer erzeugt für jede generische Definition eine Klasse im ByteCode, in der Object für die generischen
Typparameter verwendet wird. Er setzt Laufzeitprüfungen ein, um zu prüfen, dass die ursprünglich generischen Typen
korrekt verwendet wurden.
© 2010 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
Stack<Float> taschenRechner = new Stack<Float>();
Stack<Frame> windowMgr = new Stack<Frame>();
Stack<float>* taschenRechner = new Stack<float>();
Stack<Frame>* windowMgr = new Stack<Frame>();
Auch Grundtypen wie int und float können als aktuelle generische Parameter eingesetzt
werden.
GPS-5-10n
GPS-5-11
Nutzen generischer Definitionen
5.2 Datentypen in Programmiersprachen
Typen mit einfachen Wertemengen (1)
Typische Anwendungen:
a. Ausschnitte aus den ganzen Zahlen mit arithmetischen Operationen
unterschiedlich große Ausschnitte: Java: byte, short, int, long;
C, C++: short, int, long int, unsigned; Modula-2: INTEGER und CARDINAL
homogene Behälter-Typen, d. h. alle Elemente haben denselben Typ:
Liste, Keller, Schlange, ...
generischer Parameter ist der Elementtyp (und ggf. die Kapazität des Behälters)
b. Wahrheitswerte mit logischen Operationen
Pascal, Java: boolean = (false, true);
in C: durch int repräsentiert; 0 repräsentiert false, alle anderen Werte true
Algorithmen-Schemata: Sortieren, Suchen, etc.
generischer Parameter ist der Elementtyp mit Vergleichsfunktion
Generik sichert statische Typisierung trotz verschiedener Typen der Instanzen!
Übersetzer kann Typkonsistenz garantieren, z. B. Homogenität der Behälter
Kurzauswertung logischer Operatoren in C, C++, Java, Ada:
Operanden von links nach rechts auswerten bis das Ergebnis feststeht:
Java hat generische Definitionen erst seit Version 1.5
Behälter-Typen programmierte man vorher mit Object als Elementtyp,
dabei ist Homogenität nicht garantiert
a && b || c
i >= 0 && a[i] != x
c. Zeichen eines Zeichensatzes mit Vergleichen, z. B. char
Generische Definitionen gibt es z. B. in C++, Ada, Eiffel, Java ab 1.5
© 2013 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
Generische Definitionen sind überflüssig in dynamisch typisierten Sprachen wie Smalltalk
d. Aufzählungstypen (enumeration)
Pascal:
Farbe = (rot, blau, gelb)
C:
typedef enum {rot, blau, gelb} Farbe;
Java:
enum farbe {rot, blau, gelb}
Die Typen (a) bis (d) werden auf ganze Zahlen abgebildet (ordinal types) und können deshalb
auch exakt verglichen, zur Indizierung und in Fallunterscheidungen verwendet werden.
GPS-5-11a
GPS-5-12
Typen mit einfachen Wertemengen (2)
Verbunde
Kartesisches Produkt: D = D1 × D2 × ... × Dn mit beliebigen Typen Di; n-Tupel
e. Teilmenge der rationalen Zahlen in Gleitpunkt-Darstellung (floating point), z. B. float, mit
arithmetischen Operationen,
Gleitpunkt-Darstellung:
Tripel (s, m, e) mit Vorzeichen s, Mantisse m, Exponent e zur Basis b = 2;
Wert der Gleitpunktzahl: x = s * m * be
f.
Verbundtypen in verschiedenen Sprachen:
SML:
Pascal, Modula-2, Ada:
type Datum = record tag, monat, jahr: integer; end;
Teilmenge der komplexen Zahlen mit arithmetischen Operationen z. B. in FORTRAN
C, C++: typedef struct {int tag, monat, jahr;} Datum;
g. Ausschnittstypen (subrange)
in Pascal aus (a) bis (d): Range = 1..100;
in Ada auch aus (e) mit Größen- und Genauigkeitsangaben
Selektoren zur Benennung von Verbundkomponenten:
Datum heute = {27, 6, 2006};
heute.monat oder monat of heute
Zur Notation von Werten der Grundtypen sind Literale definiert:
z. B.
127, true, '?', 3.71E-5
Operationen:
meist nur Zuweisung; komponentenweise Vergleiche (SML) sehr aufwändig
© 2006 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
type Datum = int * int * int;
Notation für Verbundwerte:
in Algol-68, SML, Ada als Tupel:
heute := (27, 6, 2006);
in C nur für Initialisierungen:
Datum heute = {27, 6, 2006};
in Pascal, Modula-2 keine Notation für Verbundwerte
sehr lästig, da Hilfsvariable und komponentenweise Zuweisungen benötigt werden
Datum d; d.tag:=27; d.monat:=6; d.Jahr:=2006; pruefeDatum (d);
statt pruefeDatum ((27, 6, 2006));
GPS-5-13
GPS-5-14
Vergleich: Verbundwerte - Objekte
Vereinigung (undiscriminated union)
heute
27
6
2006
Verbundtypen in C, C++:
typedef struct {int tag, monat, jahr;} Datum;
Datum heute = {27, 6, 2006};
Datum d = heute; d.tag += 1;
d
Allgemeines Konzept: Vereinigung von Wertebereichen: D = D1 | D2 | ... | Dn
Ein Wert vom Typ Di ist auch ein Wert vom allgemeineren Typ D.
Variable vom Typ D können einen Wert jedes der vereinigten Typen Di aufnehmen.
28
6
2006
Problem: Welche Operationen sind auf den Inhalt solch einer Variable sicher anwendbar?
Klassen in objekt-orientierten Sprachen wie Java, C++:
class Datum {int tag, monat, jahr;}
Datum heute = new Datum (27, 6, 2006);
Datum d = heute; d.tag += 1;
heute
d
1. undiscriminated union: D = D1 | D2 | ... | Dn
28
6
2006
z. B. zwei Varianten der Darstellung von Kalenderdaten, als Tripel vom Typ Datum oder als
Nummer des Tages bezogen auf einen Referenztag, z. B.
Vergleich
union-Typ in C:
typedef union {Datum KalTag; int TagNr;} uDaten;
uDaten h;
Werte von Typen
Objekte von Klassen
habe keine Identität
haben Identität (Referenz, Speicherstelle)
beliebig kopierbar
werden nicht kopiert, sondern geklont
2 Werte sind gleich,
wenn ihre Komponenten gleich sind,
auch wenn die Werte an verschiedenen
Stellen gespeichert sind
2 Objekte sind immer verschieden,
auch wenn ihre Instanzvariablen
paarweise gleiche Werte haben.
© 2015 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
werden z. B. in Variablen gespeichert
haben eigenen Speicher
Werte haben keinen veränderlichen Zustand können veränderlichen Zustand haben
Varianten-Record in Pascal:
type uDaten = record case boolean of
true: (KalTag: Datum);
false: (TagNr: integer);
end;
var h: uDAten;
Durch den Zugriff wird ein Wert vom Typ D als Wert vom Typ Di interpretiert; unsicher!
z. B. h.TagNr = 4342; oder t = h.KalTag.tag;
Speicher wird für die größte Alternative angelegt und für kleinere Alternativen ggf. nicht genutzt.
GPS-5-14a
GPS-5-15
Vereinigung (discriminated union)
Reihungen (Arrays)
Abbildung des Indextyps auf den Elementtyp:
oder kartesisches Produkt mit fester Anzahl Komponenten
Allgemeines Konzept: Vereinigung von Wertebereichen: D = D1 | D2 | ... | Dn (wie auf 5.14)
Problem: Welche Operationen sind auf den Inhalt solch einer Variable sicher anwendbar?
in Pascal-Notation: type D = array [ I ] of E
2. discriminated union: D = T × (D1 | D2 | ... | Dn) mit T = {t1, t2, ... , tn}
Unterscheidungskomponente vom Typ T (tag field) ist Teil des Wertes und kennzeichnet
Zugehörigkeit zu einem Di; z. B.
Indexgrenzen, alternative Konzepte:
statische Eigenschaft des Typs (Pascal):
statische Eigenschaft der Reihungsvariablen (C):
dynamische Eigenschaft des Typs (Ada):
dynamisch, bei Bildung von Werten, Objekten (Java)
SML (implizite Unterscheidungskomponente):
datatype Daten = KalTag of Datum | TagNr of int;
Operationen:
Zuweisung, Indizierung als Zugriffsfunktion: x[i] y[i][j]
in C, C++, FORTRAN ohne Prüfung des Index gegen die Grenzen
© 2006 bei Prof. Dr. Uwe Kastens
Sichere Zugriffe durch Prüfung des Wertes der Unterscheidungskomponente oder
Fallunterscheidung darüber.
© 2015 bei Prof. Dr. Uwe Kastens
array [0..9] of integer;
int a[10];
array (0..m*n) of float;
int[] a = new int[m*n];
Mehrstufige Reihungen: Elementtyp ist Reihungstyp:
array [ I1 ] of array [ I2 ] of E
kurz: array [ I1, I2 ] of E
zeilenweise Zusammenfassung in fast allen Sprachen; nur in FORTRAN spaltenweise
Pascal, Modula-2, Ada (explizite Unterscheidungskomponente):
type uDaten = record case IstKalTag: boolean of
true: (KalTag: Datum);
false: (TagNr: integer);
end;
Gleiches Prinzip in objekt-orientierten Sprachen (implizite Unterscheidungskomponente):
allgemeine Oberklasse mit speziellen Unterklassen
class Daten { ... }
class Datum extends Daten {int tag, monat, jahr;}
class TagNum extends Daten {int TagNr;}
D = I -> E
D = E × E × ... × E
y[i,j]
Notation für Reihungswerte in Ausdrücken: (fehlen in vielen Sprachen; vgl. Verbunde)
Algol-68:
a := (2, 0, 0, 3, 0, 0);
Ada:
a := ( 2 | 4 => 3, others => 0);
C:
int a[6] = {2, 0, 0, 3, 0, 0};
nur in Initialisierungen
Java:
int[] a = {2, 0, 0, 3, 0, 0};
a = new int [] {2, 0, 0, 3, 0, 0};
Pascal:
keine
GPS-5-16
GPS-5-17
Speicherung von Arrays durch Pointer-Bäume
Linearisierte Speicherung von Arrays
Ein n-dimensionales Array mit explizit gegebenen Unter- und Obergrenzen
(Pascal-Notation):
10
1. Ebene
1. Zeile
a: array[u1..o1, u2..o2, ..., un..on] of real;
wird z. B. in Java als Baum von linearen Arrays gespeichert
n-1 Ebenen von Pointer-Arrays und Daten Arrays auf der n-ten Ebene
anf
store[anf] ...store[anf + anz * es - 1]
5
4
Quader
10
u1
Ebenen
Zeilen
zeilenweise Linearisierung eines n-stufigen Arrays (z. B. in Pascal):
a: array[u1..o1, u2..o2, ..., un..on] of real;
u3
u2
abgebildet auf linearen Speicher, z. B. Byte-Array store ab Index anf:
store[anf] ... store[anf + anz * es - 1]
mit Anzahl der Elemente
anz = sp1 * sp2 * ... * spn
i-te Indexspanne
spi = oi - ui + 1
Elementgröße in Bytes
es
o3
5
...
o2
o1
...
u3
4
Jedes einzelne Array kann separat, dynamisch, gestreut im Speicher angelegt werden;
nicht alle Teil-Arrays müssen sofort angelegt werden
© 2006 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
o3
Indexabbildung: a[i1, i2, ..., in] entspricht store[k] mit
k = anf + (i1-u1)*sp2*sp3*...*spn*es +
(i2-u2)*
sp3*...*spn*es +...+
(in-un)*
es
= (...(i1*sp2 + i2)*sp3 + i3)* ...+ in)*es + konstanter Term
GPS-5-18
GPS-5.18a
Funktionen
Beispiel für Verletzung der Laufzeitkeller-Disziplin
Typ einer Funktion ist ihre Signatur: D = P -> R mit Parametertyp P, Ergebnistyp R
mehrere Parameter entspricht Parametertupel P = P1 × ... × Pn,
kein Parameter oder Ergebnis: P bzw. R ist leerer Typ (void in Java, C, C++; unit in SML)
Funktion höherer Ordnung (Higher Order Function):
Funktion mit einer Funktion als Parameter oder Ergebnis, z. B. (int×(int->int))->int
Operationen: Aufruf
Funktionen in imperativen Sprachen: nicht als Ausdruck, nur als Deklaration
Funktionen in funktionalen Sprachen:
uneingeschränkte Verwendung auch als Datenobjekte;
Aufrufschachteln bleiben solange erhalten, wie sie gebraucht werden
Notation für eine Funktion als Wert: Lambda-Ausdruck, meist nur in funktionalen Sprachen:
SML:
fn a => 2 * a
Algol-68:
(int a) int: 2 * a
© 2013 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
Funktionen als Parameter in den meisten Sprachen.
Geschachtelte Funktionen in Pascal, Modula-2, Ada - nicht in C.
Globale Funktionen als Funktionsergebnis und als Daten in C und Modula-2.
Diese Einschränkungen garantieren die Laufzeitkeller-Disziplin:
Beim Aufruf müssen alle statischen Vorgänger noch auf dem Laufzeitkeller sein.
In imperativen Sprachen ist die Verwendung von Funktionen so eingeschränkt, dass bei Aufruf
einer Funktion die Umgebung des Aufrufes (d. h. alle statischen Vorgänger-Schachteln) noch
auf dem Laufzeitkeller liegen.
Es darf z. B. nicht eine eingeschachtelte Funktion an eine globale Variable zugewiesen und
dann aufgerufen werden (vgl. GPS-4.6):
Laufzeitkeller
Programm mit
bei letztem Aufruf
geschachtelten Funktionen
bei 1. Aufruf von r
von r über ff()
float a;
statischer
a:
a:
h fct ff;
Vorgänger
ff:
h
h ff: r
?
q
q:
q:
int i;
q i:
b:
r
r:
r
b=i+1;
int b;
i:
q
b=i+1;
r:
if(..) q();
q i:
r:
r();
ff = r;
b:
r
q();
b=i+1;
ff();
GPS-5-19
GPS-5-20
Mengen
Stellen (Referenzen, Pointer)
Wertebereich ist die Potenzmenge:
D = Ρ ( De) oder
Menge der charakteristischen Funktionen D = De -> bool mit Elementtyp De
De muss meist einfach, geordnet und von beschränkter Kardinalität sein.
(Allgemeine Mengentypen z. B. in der Spezifikationssprache SETL.)
Wertebereich D = SW | {nil}
SW: Speicherstellen, die Werte eines Typs W aufnehmen können.
nil eindeutige Referenz, verschieden von allen Speicherstellen
Operationen: Zuweisung, Identitätsvergleich, Inhalt
Operationen: Mengenoperationen und Vergleiche
z. B. in Pascal:
var m, m1, m2: set of 0..15;
e in m
m1 + m2
m1 * m2
Wertnotation und Konstruktor:
a. Stelle einer deklarierten Variable, z. B. in C: int i; int *p = &i;
b. Stelle eines dynamisch generierten Objektes als Ergebnis eines Konstruktoraufrufs,
z. B. in Java Circles cir = new Circles (0, 0, 1.0);
m1 - m2
Notation für Mengenwerte: in Pascal: [1, 3, 5]
Stellen als Datenobjekte werden nur in imperativen Sprachen benötigt!
Sprachen ohne Zuweisungen brauchen nicht zwischen einer Stelle und ihrem Inhalt zu
unterscheiden ("referentielle Transparenz")
Objekte in objektorientierten Sprachen haben eine Stelle.
Sie bestimmt die Identität des Objektes.
in Modula-2: vordefinierter Typ
BITSET = SET OF [0..l-1] mit l Bits im Speicherwort.
© 2006 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
Effiziente Implementierung durch Bit-Vektor (charakteristische Funktion):
array [De] of boolean
mit logischen Operationen auf Speicherworten als Mengenoperationen.
in C:
kein Mengentyp, aber logische Operationen |, &, ~, ^
auf Bitmustern vom Typ unsigned.
GPS-5-21
GPS-6-1
Zusammenfassung zum Kapitel 5
6. Funktionen, Parameterübergabe
Mit den Vorlesungen und Übungen zu Kapitel 5 sollen Sie nun Folgendes
können:
Themen dieses Kapitels:
5.1 Allgemeine Begriffe zu Datentypen
• Typeigenschaften von Programmiersprachen verstehen und mit
• Begriffe zu Funktionen und Aufrufen
treffenden Begriffen korrekt beschreiben
• Parameterübergabearten
• Mit den abstrakten Konzepten beliebig strukturierte Typen entwerfen
call-by-value, call-by-reference, call-by-value-and-result
in verschiedenen Sprachen
• Parametrisierung und generische Definition von Typen unterscheiden
und anwenden
5.2 Datentypen in Programmiersprachen
• Ausprägungen der abstrakten Typkonzepte in den Typen von
Programmiersprachen erkennen
• Die Begriffe Klassen, Typen, Objekte, Werte sicher und korrekt
• Die Vorkommen von Typkonzepten in wichtigen Programmiersprachen
kennen
• Speicherung von Reihungen verstehen
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
verwenden
GPS-6-2
GPS-6-2a
Begriffe zu Funktionen und Aufrufen
Ausführung eines Funktionsaufrufes
Funktionen sind Abstraktionen von Rechenvorschriften.
Funktionen, die kein Ergebnis liefern, nennt man auch Prozeduren.
In objektorientierten Sprachen nennt man Funktionen auch Methoden.
Das Prinzip der Funktionsaufrufe ist in fast allen Sprachen gleich:
Ein Aufruf der Form
Funktionsausdruck
(aktuelle Parmeter)
wird in 3 Schritten ausgeführt
Effekte eines Funktionsaufrufes:
Berechnung des Funktionsergebnis und
ggf. der Ausgabeparameter aus den
Eingabeparametern.
Effekt
Seiteneffekte:
globale Variable schreiben,
Ein- und Ausgabe
Seiteneffekt
1. Funktionsausdruck auswerten, liefert eine Funktion
Ergebnis
Eingabeparameter
Aufruf
2. Aktuelle Parameter auswerten und an formale Parameter der Funktion binden nach den
speziellen Regeln der Parameterübergabe; Schachtel auf dem Laufzeitkeller bilden.
Ausgabeparameter
3. Mit diesen Bindungen den Rumpf der Funktion ausführen und ggf. das Ergebnis des
Aufrufes berechnen; Schachtel vom Laufzeitkeller entfernen.
globale Variable
Ein- Ausgabe
Beispiel:
Formale Parameter (FP): Namen für Parameter in der Funktionsdefinition.
Aktuelle Parameter (AP): Ausdrücke im Aufruf, deren Werte oder Stellen übergeben werden.
Verschiedene Arten der Parameterübergabe:
call-by-value, call-by-reference, call-by-result, call-by-value-and-result, (call-by-name)
a[i].next.m
(x*y, b[j])
1. liefert Funktion
Sqr (x+y)
© 2006 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
int Sqr (int i) { return i*i; }
z =
2. liefert zwei AP-Werte, werden an FP gebunden
3. Ausführung des Funktionsrumpfes liefert ein Ergebnis
GPS-6-3
GPS-6-4
Beispiel zur Parameterübergabe
Call-by-value
Der formale Parameter ist eine lokale Variable, die mit dem Wert des aktuellen
Parameters initialisiert wird.
program
i: integer;
a: array [1..6] of integer;
Zuweisungen im Funktionsrumpf haben keine Wirkung auf die aktuellen Parameter eines
Aufrufes.
begin
i:= 3; a[3] := 6; a[6] := 10;
output i, a[3];
/* 1 aktuelle Param. vor Aufruf */
p (i, a[i]);
output i, a[3];
/* 5 aktuelle Param. nach Aufruf */
end
Die Werte der aktuellen Parameter werden in die Parametervariablen kopiert.
Sprachen: fast alle Sprachen, z. B. Java, C, C++, Pascal, Modula-2, Ada, FORTRAN
Variante call-by-strict-value:
Der formale Parameter ist ein Name für den Wert des aktuellen Parameters.
Zuweisungen im Funktionsrumpf an formale Parameter sind nicht möglich.
Implementierung:
a. wie call-by-value und Zuweisungen durch Übersetzer verbieten
© 2010 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
procedure p (x: integer, y: integer)
t: integer;
begin
output x, y;
/* 2 formale Param. wie übergeben */
t := x; x := y; y := t;
output x, y;
/* 3 formale Param. nach Zuweisungen */
output i, a[i];
/* 4 globale Variable der akt. Param.*/
end;
b. wie call-by-reference und Zuweisungen durch Übersetzer verbieten; erspart Kopieren
Sprachen: Algol-68, funktionale Sprachen
GPS-6-5
GPS-6-6
Call-by-reference
Call-by-result
Der formale Parameter ist eine lokale, nicht initialisierte Variable. Ihr Wert wird nach
erfolgreichem Abarbeiten des Aufrufes an die Stelle des aktuellen Parameters
zugewiesen. Die Stelle des aktuellen Parameters wird beim Aufruf bestimmt.
Der formale Parameter ist ein Name für die Stelle des aktuellen Parameters. Sie wird zum
Zeitpunkt des Aufrufs bestimmt.
geeignet für Eingabe- und Ausgabeparameter (transient)
Der aktuelle Parameter muss eine Stelle haben: unzulässig:
h (5) oder h (i+1)
Stelle des Elementes a[i] wird bei Beginn des Aufrufes bestimmt: h (a[i])
Jede Operation mit dem formalen Parameter wirkt sofort auf den aktuellen Parameter.
Geeignet als Ausgabeparameter.
Die Wirkung auf den aktuellen Parameter tritt erst beim Abschluss des Aufrufs ein.
Aktueller Parameter muss eine Stelle haben.
Kopieren erforderlich.
Sprachen: Ada (out-Parameter)
Aliasing: Mehrere Namen für dieselbe Variable (aktueller und formaler Parameter)
Call-by-value-and-result
Vorsicht bei mehreren gleichen aktuellen Parametern! g (x, x)
Der formale Parameter ist eine lokale Variable, die mit dem Wert des aktuellen Parameters
initialisiert wird. Ihr Wert wird nach erfolgreichem Abarbeiten des Aufrufes an die Stelle des
aktuellen Parameters zugewiesen. Die Stelle des aktuellen Parameters wird beim Aufruf
bestimmt.
Sprachen: Pascal, Modula-2, FORTRAN, C++
© 2006 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
Implementierung:
Der formale Parameter wird eine Referenzvariable. Sie wird bei einem Aufruf initialisiert mit der
Stelle des aktuellen Parameters. Bei jedem Zugriff wird einmal zusätzlich dereferenziert.
Geeignet als Ein- und Ausgabeparameter (transient);
Die Wirkung auf den aktuellen Parameter tritt erst beim Abschluss des Aufrufs ein.
Aktueller Parameter muss eine Stelle haben.
Zweimal Kopieren erforderlich.
Sprachen: Ada (in out-Parameter)
GPS-6-8
GPS-6-7
Parameterübergabe in verschiedenen Sprachen
Zusammenfassung zum Kapitel 6
Java: nur call-by-value (auch Objektreferenzen werden call-by-value übergeben)
Mit den Vorlesungen und Übungen zu Kapitel 6 sollen Sie nun
Folgendes können:
Pascal, Modula-2, C++ wahlweise call-by-value, call-by-reference
C#: wahlweise call-by-value, call-by-reference, call-by-result
• Funktionen, Aufrufen und Parameterübergabe präzise mit
C: nur call-by-value;
call-by-reference kann simuliert werden durch die Übergabe von Stellen:
void p (int i, int *a) { ... *a = 42; ... }
int x;
treffenden Begriffen erklären können
• Die Arten der Parameterübergabe unterscheiden und sinnvoll
p (5, &x);
anwenden können
FORTRAN:
call-by-value, falls an den formalen Parameter nicht zugewiesen wird,
sonst call-by-reference oder call-by-value-and-result (je nach Übersetzer)
Algol-60: call-by-value, call-by-name (ist default!)
Algol-68: call-by-strict-value
funktionale Sprachen: call-by-strict-value oder lazy-evaluation (entspricht call-by-name)
• Die Parameterübergabe wichtiger Sprachen kennen
© 2005 bei Prof. Dr. Uwe Kastens
© 2015 bei Prof. Dr. Uwe Kastens
Ada: wahlweise call-by-value (in), call-by-result (out), call-by-value-and-result (in out).
Bei zusammengesetzten Objekten ist für in out auch call-by-reference möglich.
Aktuelle Parameter können auch mit den Namen der formalen benannt und dann in beliebiger
Reihenfolge angegeben werden: p (a => y[k], i => 5).
Für formale Parameter können default-Werte angegeben werden; dann kann der aktuelle
Parameter weggelassen werden.
GPS-7-1
GPS-7-2
7. Funktionale Programmierung
Functional Programming is Fun
Themen dieses Kapitels:
Fun ctional
Programming is
• Grundbegriffe und Notation von SML
• Rekursionsparadigmen: Induktion, Rekursion über Listen
Fun ctional
Programming is
• End-Rekursion und Programmiertechnik „akkumulierender Parameter“
• Berechnungsschemata mit Funktionen als Parameter
• Funktionen als Ergebnis und Programmiertechnik „Currying“
Fun ctional
Programming is
Fun ctional
Programming is
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
Fun ctional
Programming is
Fun ctional
Programming is
GPS-7-3
GPS-7-4
Übersicht zur funktionalen Programmierung
Wichtige Sprachkonstrukte von SML: Funktionen
Grundkonzepte: Funktionen und Aufrufe, Ausdrücke
keine Variablen, Zuweisungen, Ablaufstrukturen, Seiteneffekte
Funktionen können direkt notiert werden, ohne Deklaration und ohne Namen:
Funktionskonstruktor (lambda-Ausdruck: Ausdruck, der eine Funktion liefert):
fn FormalerParameter => Ausdruck
Elementare Sprachen (pure LISP) brauchen nur wenige Konzepte:
Funktionskonstruktor, bedingter Ausdruck, Literale, Listenkonstruktor und -selektoren,
Definition von Bezeichnern für Werte
fn i => 2 * i
Funktion, deren Aufruf das Doppelte ihres Parameters liefert
fn (a, b) => 2 * a + b
Beispiel, unbenannte Funktion als Parameter eines Aufrufes:
Mächtige Programmierkonzepte durch Verwendung von:
rekursiven Funktionen und Datenstrukturen,
Funktionen höherer Ordnung als Berechnungsschemata
map (fn i => 2 * i, [1, 2, 3])
Funktionaler Entwurf:
strukturell denken - nicht in Abläufen und veränderlichen Zuständen,
fokussiert auf funktionale Eigenschaften der Problemlösung,
Nähe zur Spezifikation, Verifikation, Transformation
Funktionale Sprachen:
LISP, Scheme, Hope, SML, Haskell, Miranda, ...
früher: Domäne der KI; heute: Grundwissen der Informatik, praktischer Einsatz
Funktionen haben immer einen Parameter:
statt mehrerer Parameter ein Parameter-Tupel wie (a, b)
(a, b) ist ein Muster für ein Paar als Parameter
statt keinem Parameter ein leerer Parameter vom Typ unit, entspricht void
© 2015 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
Höhere funktionale Sprachen (SML, Haskell):
statische Bindung von Bezeichnern und Typen,
völlig orthogonale, höhere Datentypen, polymorphe Funktionen (Kapitel 6),
modulare Kapselung, effiziente Implementierung
Typangaben sind optional. Trotzdem prüft der Übersetzer streng auf korrekte Typisierung.
Er berechnet die Typen aus den benutzten Operationen (Typinferenz)
Typangaben sind nötig zur Unterscheidung von int und real
fn i : int => i * i
GPS-7-4a
GPS-7-4b
Wichtige Sprachkonstrukte von SML: Funktionsaufrufe
Wichtige Sprachkonstrukte von SML: Definitionen
allgemeine Form eines Aufrufes: Funktionsausdruck Parameterausdruck
Eine Definition bindet den Wert eines Ausdrucks an einen Namen:
val
val
val
val
Dupl 3
(fn i => 2 * i) 3
Klammern können den Funktionsausdruck m it dem aktuellen Parameter zusammenfassen:
(fn i => 2 * i) (Dupl 3)
four = 4;
Dupl = fn i => 2 * i;
Foo = fn i => (i, 2*i);
x = Dupl four;
Eine Definition kann ein Tupel von Werten an ein Tupel von Namen, sog. Muster, binden:
allgemeine Form:
Parametertupel werden geklammert:
val Muster = Ausdruck;
(fn (a, b) => 2 * a + b) (4, 2)
val (a, b) = Foo 3;
Der Aufruf Foo 3 liefert ein Paar von Werten, sie werden gebunden an die Namen a und b im
Muster für Paare (a, b).
Auswertung von Funktionsaufrufen wie in GPS-6-2a beschrieben.
Parameterübergabe: call-by-strict-value
© 2013 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
Kurzform für Funktionsdefinitionen:
fun Name FormalerParameter = Ausdruck;
fun Dupl i = 2 * i;
fun Fac n = if n <= 1 then 1 else n * Fac (n-1);
bedingter Ausdruck: Ergebnis ist der Wert des then- oder else-Ausdruckes
GPS-7-5
GPS-7-5a
Rekursionsparadigma Induktion
Induktion - effizientere Rekursion
Funktionen für induktive Berechnungen sollen schematisch entworfen werden:
Induktive Definition und rekursive Funktionen zur Berechnung von Fibonacci-Zahlen:
Beispiele:
n! =
© 2011 bei Prof. Dr. Uwe Kastens
bn =
1
für n <= 1
n*(n-1)!
für n > 1
1.0
für n <= 0
b*bn-1
für n > 0
induktive Definition:
rekursive Funktionsdefinitionen:
fun Fac n =
if n <= 1
then 1
else n * Fac (n-1);
Fib(n) =
fun Power (n, b) =
if n <= 0
then 1.0
else b * Power (n-1, b);
Schema:
fun F a = if Bedingung über a
then nicht-rekursiver Ausdruck über a
else rekursiver Ausdruck über F("verkleinertes a")
0
für n = 0
1
für n = 1
Fib(n-1)+Fib(n-2) für n > 1
rekursive Funktionsdefinition:
fun Fib n =
if n = 0
then 0
else if n = 1
then 1
else Fib(n-1)+Fib (n-2);
Fib effizienter:
Zwischenergebnisse als Parameter, Induktion aufsteigend
(allgemeine Technik siehe „Akkumulierende Parameter“):
© 2006 bei Prof. Dr. Uwe Kastens
induktive Definitionen:
fun AFib (n, alt, neu) =
if n = 1 then neu
else AFib (n-1, neu, alt+neu);
fun Fib n = if n = 0 then 0 else AFib (n, 0, 1);
GPS-7-5b
GPS-7-6
Funktionsdefinition mit Fallunterscheidung
Funktionen können übersichtlicher definiert werden durch
• Fallunterscheidung über den Parameter - statt bedingter Ausdruck als Rumpf,
Parametrisierter Typ für lineare Listen vordefiniert: (Typparameter 'a; polymorpher Typ)
datatype 'a list = nil | :: of ('a * 'a list)
• formuliert durch Muster
definert den 0-stelligen Konstruktor nil und den 2-stelligen Konstruktor ::
• Bezeichner darin werden an Teil-Werte des aktuellen Parameters gebunden
Schreibweisen für Listen:
x :: xs
eine Liste mit erstem Element x und der Restliste xs
[1, 2, 3]
für 1 :: 2 :: 3 :: nil
Fallunterscheidung mit Mustern:
fun Fac n =
if n=1 then 1
else n * Fac (n-1);
fun
|
Fac (1) = 1
Fac (n) = n * Fac (n-1);
fun
|
Power (0, b) = 1.0
Power (n, b) =
b * Power (n-1, b);
fun
|
|
Fib (0) = 0
Fib (1) = 1
Fib (n) =
Fib(n-1) + Fib(n-2);
Die Muster werden in der angegebenen Reihenfolge gegen den aktuellen Parameter
geprüft. Es wird der erste Fall gewählt, dessen Muster trifft. Deshalb muss ein allgemeiner
„catch-all“-Fall am Ende stehen.
Nützliche vordefinierte Funktionen auf Listen:
hd l
erstes Element von l
tl l
Liste l ohne erstes Element
length l
Länge von l
null l
Prädikat: ist l gleich nil?
l1 @ l2
Liste aus Verkettung von l1 und l2
© 2005 bei Prof. Dr. Uwe Kastens
bedingter Ausdruck als Rumpf:
fun Power (n, b) =
if n = 0
then 1.0
else b * Power (n-1, b);
© 2006 bei Prof. Dr. Uwe Kastens
Listen als rekursive Datentypen
Funktion, die die Elemente einer Liste addiert:
fun Sum l = if null l then 0
else (hd l) + Sum (tl l);
Signatur:
Sum: int list -> int
GPS-7-6a
GPS-7-7
Konkatenation von Listen
Einige Funktionen über Listen
In funktionalen Sprachen werden Werte nie geändert.
Liste[n,...,1] erzeugen:
fun MkList 0 = nil
|
Mklist n = n :: MkList (n-1);
Signatur:
MkList: int -> int list
Fallunterscheidung mit Listenkonstruktoren nil und :: in Mustern:
Summe der Listenelemente:
fun Sum (nil)
= 0
|
Sum (h::t) = h + Sum t;
Bei der Konkatenation zweier Listen wird die Liste des linken Operands kopiert.
val l1 = [1, 2, 3];
l1
val l2 = [4, 5];
nil
1
2
3
val l3 = l1 @ l2;
l2
5
Polymorphe Signatur:
l3
1
2
3
© 2006 bei Prof. Dr. Uwe Kastens
4
© 2006 bei Prof. Dr. Uwe Kastens
Prädikat: Ist das Element in der Liste enthalten?:
fun Member (nil, m)= false
|
Member (h::t,m)= if h = m then true else Member (t,m);
nil
Member: (’a list * ’a) -> bool
Liste als Konkatenation zweier Listen berechnen (@-Operator):
fun Append (nil, r)= r
|
Append (l, nil)= l
|
Append (h::t, r)= h :: Append (t, r);
Die linke Liste wird neu aufgebaut!
Polymorphe Signatur:
Append: (’a list * ’a list) -> ’a list
GPS-7-8
GPS-7-9
Rekursionsschema Listen-Rekursion
Einige Funktionen über Bäumen
lineare Listen sind als rekursiver Datentyp definiert:
datatype 'a list = nil | :: of ('a * 'a list)
Parametrisierter Typ für Bäume:
datatype 'a tree = node of ('a tree * 'a * 'a tree) | treeNil
Paradigma: Funktionen haben die gleiche Rekursionsstruktur wie der Datentyp.
Paradigma: Funktionen haben die gleiche Rekursionsstruktur wie der Datentyp:
fun F l =
if l=nil
fun Sum l = if l=nil
Beispiel: einen Baum spiegeln
then nicht-rekursiver Ausdruck
else Ausdruck über hd l und F(tl l);
fun Flip (treeNil)
|
Flip (node (l, v, r))
then 0
else (hd l) + Sum (tl l);
polymorphe Signatur:
= treeNil
= node (Flip r, v, Flip l);
Flip: ’a tree -> ’a tree
Beispiel: einen Baum auf eine Liste der Knotenwerte abbilden (hier in Infix-Form)
fun F (nil)
|
F (h::t)
= nicht-rekursiver Ausdruck
= Ausdruck über h und F t
fun Sum (nil)
|
Sum (h::t)
= 0
= h + Sum t;
fun Flatten (treeNil)
= nil
|
Flatten (node (l, v, r)) = (Flatten l) @ (v :: (Flatten r));
© 2010 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
Dasselbe in Kurzschreibweise mit Fallunterscheidung:
polymorphe Signatur:
Flatten: ’a tree -> ’a list
Präfix-Form:
...
Postfix-Form:
...
GPS-7-10
GPS-7-10a
End-Rekursion
End-Rekursion entspricht Schleife
Jede imperative Schleife kann in eine end-rekursive Funktion transformiert werden.
Allgemeines Schema:
while ( p(x) ) {x = r(x);} return q(x);
fun While x = if p x then While (r x) else q x;
In einer Funktion f heißt ein Aufruf von f end-rekursiv, wenn er (als letzte Operation)
das Funktionsergebnis bestimmt, sonst heißt er zentral-rekursiv.
Eine Funktion heißt end-rekursiv, wenn alle rekursiven Aufrufe end-rekursiv sind.
Member ist end-rekursiv:
Sum ist zentral-rekursiv:
fun Member (l, a) =
if null l then false
else if (hd l) = a
then true
else Member (tl l, a);
fun Sum (nil)= 0
|
Sum (h::t)= h + (Sum t);
Jede end-rekursive Funktion kann in eine imperative Form transformiert werden:
Jeder end-rekursive Aufruf wird durch einen Sprung an den Anfang der Funktion
(oder durch eine Schleife) ersetzt:
fun Member (l, a) =
if null l then false
else if (hd l) = a then true else Member (tl l, a);
F
[2,3]
5
F
[3]
5
F
[]
5
F
Laufzeitkeller für Member ([1,2,3], 5)
Ergebnis wird durchgereicht ohne Operation darauf
© 2014 bei Prof. Dr. Uwe Kastens
© 2010 bei Prof. Dr. Uwe Kastens
Parameter Ergebnis
[1,2,3]
5
Imperativ in C:
int Member (ElemList l, Elem a)
{ Begin: if (null (l)) return 0 /*false*/;
else if (hd (l) == a) return 1 /*true*/;
else { l = tl (l); goto Begin;}
}
Gute Übersetzer leisten diese Optimierung automatisch - auch in imperativen Sprachen.
GPS-7-11
GPS-7-11a
Technik: Akkumulierender Parameter
Liste umkehren mit akkumulierendem Parameter
Liste umkehren:
fun Reverse (nil)= nil
|
Reverse (h::t)= Append (Reverse t, h::nil);
Unter bestimmten Voraussetzungen können zentral-rekursive Funktionen in end-rekursive
transformiert werden:
Ein akkumulierender Parameter führt das bisher berechnete Zwischenergebnis mit durch die
Rekursion. Die Berechnungsrichtung wird umgekehrt,
Append dupliziert die linke Liste bei jeder Rekursion von Reverse,
benötigt also k mal ::, wenn k die Länge der linken Liste ist. Insgesamt benötigt Reverse
wegen der Rekursion (n-1) + (n-2) + ... + 1 mal ::, also Aufwand O(n2).
z. B.:Summe der Elemente einer Liste zentral-rekursiv:
fun Sum (nil)= 0
Sum [1, 2, 3, 4] berechnet
|
Sum (h::t)= h + (Sum t);
1 + (2 + (3 + (4 + (0))))
Transformation von Reverse führt zu linearem Aufwand:
fun AReverse (nil, a)= a
|
AReverse (h::t,a)= AReverse (t, h::a);
fun Reverse l = AReverse (l, nil);
transformiert in end-rekursiv:
fun
|
ASum (nil, a:int) = a
ASum (h::t,a)
= ASum (t, a + h);
Idee:
ASum ([1, 2, 3, 4], 0) berechnet
((((0 + 1) + 2) + 3) + 4)
Die Verknüpfung (hier +) muß assoziativ sein.
Initial wird mit dem neutralen Element der Verknüpfung (hier 0) aufgerufen.
Gleiche Technik bei AFib (GPS-7.5a); dort 2 akkumulierende Parameter.
schon umgekehrt
noch umkehren
h
© 2006 bei Prof. Dr. Uwe Kastens
© 2006 bei Prof. Dr. Uwe Kastens
fun Sum l = ASum (l, 0);
t
t
a
a
h
::
GPS-7-12
GPS-7-12a
Funktionen höherer Ordnung (Parameter): map
Funktionen höherer Ordnung (Parameter): foldl
Berechnungsschemata mit Funktionen als Parameter
foldl verknüpft Listenelemente von links nach rechts
Beispiel: eine Liste elementweise transformieren
fun map(f, nil) = nil
|
map(f, h::t) = (f h) :: map (f, t);
Signatur: map: ((’a ->’b) * ’a list) -> ’b list
foldl ist mit akkumulierendem Parameter definiert:
fun foldl (f, a, nil) = a
|
foldl (f, a, h::t)= foldl (f, f (a, h), t);
Signatur: foldl: ((’b * ’a)->’b * ’b * ’a list) -> ’b
Anwendungen von Map, z. B.
map (fn i => i*2.5, [1.0,2.0,3.0]);Ergebnis:[2.5, 5.0, 7.5]
map (fn x => (x,x), [1,2,3]);
Ergebnis: [(1,1), (2,2), (3,3)]
Für
wird berechnet
foldl (f, 0, [1, 2, 3,
f(f(f(f(0, 1), 2), 3), 4)
4])
Anwendungen von foldl
assoziative Verknüpfungsfunktion und neutrales Element einsetzen:
fun Sum l = foldl (fn (a, h:int) => a+h, 0, l);
© 2011 bei Prof. Dr. Uwe Kastens
© 2013 bei Prof. Dr. Uwe Kastens
Verknüpfung: Addition; Sum addiert Listenelemente
fun Reverse l = foldl (fn (a, h) => h::a, nil, l);
Verknüpfung: Liste vorne verlängern; Reverse kehrt Liste um
GPS-7-13
GPS-7-14
Polynomberechnung mit foldl
Funktionen höherer Ordnung (Ergebnis)
Einfaches Beispiel für Funktion als Ergebnis:
fun Choice true
= (fn x => x + 1)
|
Choice false = (fn x => x * 2);
Ein Polynom anxn +...+ a1x + a0 sei durch seine Koeffizientenliste [an,...,a1, a0] dargestellt
Berechnung eines Polynomwertes an der Stelle x nach dem Horner-Schema:
Signatur Choice: bool -> (int -> int)
(...((0 * x + an) * x + an-1) * x +...+ a1) * x + a0
Meist sind freie Variable der Ergebnisfunktion an Parameterwerte der konstruierenden
Funktion gebunden:
fun Comp (f, g) = fn x => f (g x); Hintereinanderausführung von g und f
Funktion Horner berechnet den Polynomwert für x nach dem Horner-Schema:
fun Horner (koeff, x:real) = foldl (fn(a, h)=>a*x+h, 0.0, koeff);
Verknüpfungsfunktion fn(a, h)=>a*x+h hat freie Variable x,
sie ist gebunden als Parameter von Horner
Signatur Comp:('b->'c * 'a->'b) -> ('a->'c)
Anwendung: z. B. Bildung einer benannten Funktion Hoch4
val Hoch4 = Comp (Sqr, Sqr);
© 2006 bei Prof. Dr. Uwe Kastens
© 2014 bei Prof. Dr. Uwe Kastens
Aufrufe z. B.
Horner ([1.0, 2.0, 3.0], 10.0);
Horner ([1.0, 2.0, 3.0], 2.0);
GPS-7-15
GPS-7-15a
Currying
Kurzschreibweise für Funktionen in Curry-Form
Currying: Eine Funktion mit Parametertupel wird umgeformt in eine Funktion mit einfachem
Parameter und einer Ergebnisfunktion; z. B. schrittweise Bindung der Parameter:
fun
Signatur
Parametertupel
Add (x, y:int) = x + y;
Add: (int * int) -> int
In Aufrufen müssen alle Parameter(komponenten)
sofort angegeben werden
Add (3, 5)
Curry-Form
fun CAdd x = fn y:int => x + y;
CAdd: int -> (int -> int)
Signatur CPower: int -> (real -> real)
Kurzschreibweise für Funktion in Curry-Form:
fun CPower n b =
if n = 0 then 1.0 else b * CPower (n-1) b;
können die Parameter schrittweise
gebunden werden:
(CAdd 3) 5
Auch rekursiv:
fun CPower n = fn b =>
if n = 0 then 1.0 else b * CPower (n-1) b;
Funktion Horner berechnet den Polynomwert für x nach dem Horner-Schema (GPS-7.13),
in Tupelform:
fun Horner (koeff, x:real) = foldl (fn(a, h)=>a*x+h, 0.0, koeff);
Signatur CPower: int -> (real -> real)
Horner-Funktion in Curry-Form:
CHorner liefert eine Funktion; die Koeffizientenliste ist darin gebunden:
fun CHorner koeff x:real = foldl (fn(a, h)=>a*x+h, 0.0, koeff);
Signatur CHorner: (real list) -> (real -> real)
(Hoch3 4)
((CPower 3) 4)
liefert 64
liefert 64
eine Funktion, die „hoch 3“ berechnet
© 2011 bei Prof. Dr. Uwe Kastens
Anwendung:
val Hoch3 = CPower 3;
© 2013 bei Prof. Dr. Uwe Kastens
Langform:
fun CPower n = fn b =>
if n = 0 then 1.0 else b * CPower (n-1) b;
Aufruf:
val MyPoly = CHorner [1.0, 2.0,3.0];
...
MyPoly 10.0
GPS-7-16
GPS-8-1
Zusammenfassung zum Kapitel 7
8. Logische Programmierung
Mit den Vorlesungen und Übungen zu Kapitel 7 sollen Sie nun
Folgendes können:
Themen dieses Kapitels:
• Prolog-Notation und kleine Beispiele
• Funktionale Programme unter Verwendung treffender Begriffe präzise
• prädikatenlogische Grundlagen
erklären
• Interpretationsschema
• Funktionen in einfacher Notation von SML lesen und schreiben
• Anwendbarkeit von Klauseln, Unifikation
• Rekursionsparadigmen Induktion, Rekursion über Listen anwenden
• kleine Anwendungen
• End-Rekursion erkennen und Programmiertechnik „akkumulierender
Parameter“ anwenden
• Berechnungsschemata mit Funktionen als Parameter anwenden
© 2011 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
• Programmiertechnik „Currying“ verstehen und anwenden
GPS-8-2
GPS-8-3
Übersicht zur logischen Programmierung
Prolog Übersicht
Deklaratives Programmieren:
Problem beschreiben statt Algorithmus implementieren (idealisiert).
Das System findet die Lösung selbst, z. B. Sortieren einer Liste:
Wichtigste logische Programmiersprache: Prolog (Colmerauer, Roussel, 1971)
Typische Anwendungen: Sprachverarbeitung, Expertensysteme, Datenbank-Management
Ein Programm ist eine Folge von Klauseln (Fakten, Regeln, eine Anfrage)
formuliert über Terme.
sort(old, new) <= permute(old, new) ∧ sorted(new)
sorted(list) <= ∀j such that 1 <= j < n: list(j) <= list(j+1)
Relationen bzw. Prädikate (statt Funktionen):
(a, b) ∈ R ⊆ (S x T)
magEssen(hans, salat)
Programmkonstrukte entsprechen eingeschränkten prädikatenlogischen Formeln
∀X,Y,Z: grossMutterVon(X, Z) <= mutterVon(X, Y)∧elternteilVon(Y, Z)
?-sort([9,4,6,2], X).
Antwort:
X = [2,4,6,9]
Datenmodell: strukturierte Terme mit Variablen (mathematisch, nicht imperativ);
Bindung von Termen an Variable durch Unifikation
Fakten
parent(X, Y) :- mother(X, Y).
parent(X, Y) :- father(X, Y).
Regeln
?- parent(X, jake)
Anfrage
Antworten:
© 2015 bei Prof. Dr. Uwe Kastens
© 2011 bei Prof. Dr. Uwe Kastens
Resolution implementiert durch Interpretierer:
Programm ist Menge von PL-Formeln,
Interpretierer sucht Antworten (erfüllende Variablenbelegungen) durch Backtracking
mother(mary, jake).
mother(mary, shelley).
father(bill, jake).
X = mary
X = bill
Ein Interpretierer prüft, ob Werte an die Variablen so gebunden werden können, dass die
Anfrage mit den gegebenen Prädikaten und Regeln erfüllbar ist (Resolution).
Es wird ein universelles Suchverfahren (Backtracking) angewendet (Folie GPS-8-7).
GPS-8-4
GPS-8-4a
Prolog Sprachkonstrukte: Fakten
Prolog Sprachkonstrukte: Regeln
Fakten geben Elemente von n-stelligen Relationen bzw. Prädikaten an, z. B.
Regeln definieren n-stellige Relationen bzw. Prädikate
durch Implikationen (intensional), z. B.
stern(sonne).
stern(sirius).
planet(B) :- umkreist(B, sonne).
satellit(B) :- umkreist(B, P), planet(P).
bedeutet, sonne und sirius sind Konstante,
sie erfüllen das Prädikat (die 1-stellige Relation) stern.
bedeutet in PL:
∀ B: planet(B)<= umkreist(B, sonne)
∀ B,P: satellit(B) <= umkreist(B, P) ∧ planet(P)
Einige Fakten, die Elemente der 2-stelligen Relation umkreist angeben:
umkreist(jupiter, sonne).
umkreist(erde, sonne).
umkreist(mars, sonne).
umkreist(mond, erde).
umkreist(phobos, mars).
In einer Klausel müssen an alle Vorkommen eines Variablennamen dieselben
Werte gebunden sein, z. B. B/mond und P/erde
Allgemein definiert man eine Relation durch mehrere Fakten und Regeln.
sie gelten dann alternativ (oder-Verknüpfung)
sonnensystem(sonne).
sonnensystem(B) :- planet(B).
sonnensystem(B) :- satellit(B).
Fakten können auch mit Variablen formuliert werden:
bedeutet in PL: ∀ X: istGleich(X,X)
Prolog hat keine Deklarationen. Namen für Prädikate, Konstante und Variablen
werden durch ihre Benutzung eingeführt.
Namen für Konstante beginnen mit kleinem, für Variable mit großem Buchstaben.
© 2011 bei Prof. Dr. Uwe Kastens
© 2011 bei Prof. Dr. Uwe Kastens
istGleich(X,X).
Man kann Relationen auch rekursiv definieren:
sonnensystem(sonne).
sonnensystem(X) :- umkreist(X, Y), sonnensystem(Y).
GPS-8-4b
GPS-8-4c
Prolog Sprachkonstrukte: Anfragen
Notation von Prolog-Programmen
Das Prolog-System überprüft, ob eine Anfrage mit den Fakten und Regeln des
gegebenen Programms (durch prädikatenlogische Resolution)
als wahr nachgewiesen werden kann.
Beliebige Folge von Klauseln: Fakten, Regeln und Anfragen (am Ende).
Klauseln mit Prädikaten p(t1, ..., tn), Terme ti
Terme sind beliebig zusammengesetzt aus Literalen, Variablen, Listen, Strukturen.
• Literale für Zahlen, Zeichen(reihen)
127 "text" 'a'
Beispiele zu den Fakten und Regeln der vorigen Folien:
Antwort:
?- umkreist(erde, sonne).
?- umkreist(mond, sonne).
yes
no
• Symbole (erste Buchstabe klein)
hans
• Variablen (erste Buchstabe groß)
X Person
_
unbenannte Variable
• Listen-Notation:
?- umkreist(mond, B).
∃B: umkreist(mond, B)
Wenn die Anfrage Variablen enthält, werden Belegungen gesucht,
mit denen die Anfrage als wahr nachgewiesen werden kann:
Antworten:
?- umkreist(mond, B).
B=erde
?- umkreist(B, sonne).
B=jupiter; B=erde; B=mars
?- umkreist(B, jupiter).
no (keine Belegung ableitbar)
?- satellit(mond).
yes
?- satellit(S).
S=mond; S=phobos
erstes Element H, Restliste T
• Strukturen:
[a, b, c]
[H | T]
kante(a, b)
Operatoren kante, - werden
ohne Definition verwendet, nicht „ausgerechnet“
Grundterm: Term ohne Variablen, z. B.
© 2011 bei Prof. Dr. Uwe Kastens
© 2011 bei Prof. Dr. Uwe Kastens
Eine Anfrage
bedeutet in PL
[]
wie H::T in SML
a - b
datum(T, M, J)
datum(11, 7, 1995)
Prolog ist nicht typisiert:
• An eine Variable können beliebige Terme gebunden werden,
• an Parameterpositionen von Prädikaten können beliebige Terme stehen.
GPS-8-5
GPS-8-6
Prädikatenlogische Grundlagen
Resolution
Prädikatenlogische Formeln (siehe Modellierung, Abschn. 4.2):
Resolution führt einen Widerspruchsbeweis für eine Anfrage:
atomare Formeln p (t1, ..., tn) bestehen aus einem Prädikat p und Termen ti
mit Variablen, z. B. last([X], X)
darauf werden logische Junktoren (¬ ∧ ∨) und Quantoren (∀ ∃) angewandt,
z. B. ∀X ∀Y: sonnensystem(X) ∨ ¬ umkreist(X, Y) ∨ ¬ sonnensystem(Y)
äquivalent zu
∀X ∀Y: sonnensystem(X) <= umkreist(X, Y) ∧ sonnensystem(Y)
Die Antwort ist gültig für alle zu einem Programm durch induktive Anwendung von Operatoren
konstruierbaren Terme (Herbrand-Universum, „Hypothese der abgeschlossenen Welt“).
Antwort Ja:
Antwort Nein:
© 2011 bei Prof. Dr. Uwe Kastens
© 2011 bei Prof. Dr. Uwe Kastens
Prolog-Regel: sonnensystem(X) :- umkreist(X,Y), sonnensystem(Y).
PL:
∀X ∀Y: sonnensystem(X)<=umkreist(X,Y)∧sonnensystem(Y).
äquivalent zu: ¬∀X ¬umkreist(X, erde) ∨ ¬umkreist(X,jupiter).
==> Anfrage bewiesen
∀X ¬umkreist(X, erde) ∨ ¬umkreist(X,jupiter).
negiert:
last ([X], X).
∀ X: last ([X], X).
Prolog-Anfrage:umkreist(X, erde), umkreist(X,jupiter).
PL:
∃X: umkreist(X, erde) ∧ umkreist(X,jupiter).
=
Prolog-Anfrage: umkreist(X, erde), umkreist(X,jupiter).
PL:
∃X: umkreist(X, erde) ∧ umkreist(X,jupiter).
äquivalent zu:
¬∀X ¬umkreist(X, erde) ∨ ¬umkreist(X,jupiter).
Allgemeine PL-Formeln werden auf die 3 Formen von Prolog-Klauseln (Horn-Klauseln)
eingeschränkt, z. B.
Prolog-Fakt:
PL:
Negierte
Anfrage
+
Fakten
Regeln
Aussage ist mit den vorhandenen Fakten und Regeln beweisbar.
Aussage ist mit den gegebenen Fakten und Regeln nicht beweisbar.
Das heißt nicht, dass sie falsch ist.
Daher kann eine Negation, wie in
Formel F gilt, wenn Formel H nicht gilt
in Prolog-Systemen nicht ausgedrückt werden.
Der vordefinierte Operator not ist „nicht-logisch“ und mit Vorsicht zu verwenden.
GPS-8-7
GPS-8-8
Lösungsbaum Beispiel
Interpretationsschema Backtracking
Beispiel (a, b, ... stehen für Prädikate; Parameterterme sind hier weggelassen):
1 a:- b, c, d.
Anfrage: ?- a, e
anwendbar
2 a:- e, f.
3 b:- f.
nicht anwendbar
4 e.
ae
5 f.
6 a:- f.
Aus Programm mit Fakten, Regeln und Anfrage spannt der Interpretierer einen
abstrakten Lösungsbaum auf (Beispiel auf nächster Folie):
Wurzel: Anfrage
Knoten: Folge noch zu verifizierender Teilziele
Kanten: anwendbare Regeln oder Fakten des Programms
Der Interpretierer iteriert folgende Schritte am aktuellen Knoten:
• Wähle ein noch zu verifizierendes Teilziel (Standard: von links nach rechts)
Falls die Folge der Teilziele leer ist, wurde eine Lösung gefunden (success);
ggf. wird nach weiteren gesucht: backtracking zum vorigen Knoten.
1
bcde
1
• Wähle eine auf das Teilziel anwendbare Klausel (Standard: Reihenfolge im Programm);
Die Reihenfolge, in der die Wahl (s.o.) getroffen wird, ist entscheidend für die Terminierung der
Suche und die Reihenfolge, in der Lösungen gefunden werden!
2
3
4
3
1
2
3
4
5
6
1
2
3
5
6
fe
4
5
6
1
2
3
4
5
6
4
5
6
fe
e
5
6
1
2
3
cde
1
4
efe
fcde
© 2011 bei Prof. Dr. Uwe Kastens
© 2011 bei Prof. Dr. Uwe Kastens
bilde einen neuen Knoten, bei dem das Teilziel durch die rechte Seite der Regel bzw. bei
einem Fakt durch nichts ersetzt wird; weiter mit diesem neuen Knoten.
Ist keine Klausel anwendbar, gibt es in diesem Teilbaum keine Lösung: backtracking zum
vorigen Knoten.
Bei rekursiven Regeln, z.b: nachbar(A, B) :- nachbar(B, A)
ist der Baum nicht endlich. Abhängig von der Suchstrategie terminiert die Suche dann
eventuell nicht.
2
2
3 4 5
fail (backtrack)
4
5
6
1
e
6
1
2
3 4 5
success
2
3
success
6
GPS-8-12
GPS-8-12a
Unifikation
Anwendung von Klauseln
siehe Modellierung, Kap. 3.1
Term: Formel bestehend aus Literalen, Variablen, Operatoren, Funktoren; z. B. X + f(2*Y)
In Klauseln werden Terme als Muster verwendet.
Darin vorkommende Variablennamen müssen konsistent an Terme gebunden werden:
last([X], X).
[X] Muster für eine einelementige Liste
heuer(T, M, datum(T, M, 2013)).Muster für ein datum mit bestimmten Teiltermen
Substitution s = [X1/e1, ..., Xn/en] angewandt auf T, geschrieben T s bedeutet:
alle Vorkommen der Variablen Xi in T werden gleichzeitig durch den Term ei ersetzt.
z. B.
Y+Y [Y/3*Z] ergibt 3*Z+3*Z
Eine Klausel (Fakt oder linke Seite einer Regel) ist auf ein Teilziel anwendbar,
wenn es einen Unifikator gibt, der die Parameterterme der Klausel und des Teilziels
paarweise gleich macht:
Fakt:
heuer(T, M, datum(T, M, 2013)).
Anfrage: ?-heuer(12, 7, Z).
Unifikator: [T/12,M/7, Z/datum(12,7,2013)]
Unifikation: Allgemeines Prinzip: Terme durch Substitution gleich machen.
gegeben: zwei Terme T1, T2
gesucht: eine Substitution U, sodass gilt T1 U = T2 U. Dann ist U ein Unifikator für T1 und T2.
Beispiele:
Fakt:
heuer(T, M, datum(T, M, 2013)).
Anfrage: ?-heuer(X, Y, datum(14, 7, 2013).
Unifikator: [X/14,T/14,Y/7, M/7]
Fakt:
last([X], X).
Teilziel: last([2,3], Z)
© 2011 bei Prof. Dr. Uwe Kastens
© 2013 bei Prof. Dr. Uwe Kastens
Regel: last([_|T], Y):- last(T, Y).
Teilziel: last([2,3], Z)
Unifikator: [T/[3], Y/Z]
nicht unifizierbar, also nicht anwendbar
Wird die Klausel angewandt, werden die Variablen gemäß Unifikator gebunden.
datum(T, M, 2011)
datum (14, 7, 2011)
f(h(a, b), g(Y),
V)
f(X,
g(h(a,c)), Z)
U =
allgemeinste Unifikatoren:
Ua = [X/h(a,b), Y/h(a,c), V/Z]
[T/14, M/7]
X+f(2*g(1))
3+f(2*Y)
Ua = [X/h(a,b), Y/h(a,c), Z/V]
U = [X/3, Y/g(1)]
nicht-allgemeinster Unifikator,
unnötige Bindungen an V und Z:
U = [X/h(a,b), Y/h(a,c), V/a, Z/a]
GPS-8-13
GPS-8-13a
Beispiel: Wege im gerichteten Graph
Rekursive Anwendung von Klauseln
Variable sind lokal für jede Anwendung einer Klausel.
Das folgende kleine Prolog-Programm beschreibt die Berechnung von Wegen in einem
gerichteten Graph.
Bei rekursiven Anwendungen entstehen neue lokale Variable.
Die Menge der gerichteten Kanten wird durch eine Folge von Fakten definiert:
Mehrfache Auftreten einer Variable stehen für denselben Wert.
kante(a,b).
kante(a,c).
...
Beispiel: mit folgenden Klauseln
(1)last([X], X).
(2)last([_|T], Y):- last(T, Y).
Die Knoten werden dabei implizit durch Namen von Symbolen eingeführt.
Die Relation weg(X,Y) gibt an, ob es einen Weg von X nach Y gibt:
wird die Anfrage berechnet:
(2)
(2)
(1)
?-last([1,2,3], Z).
last([_|T1], Y1):- last([2,3], Z).
last([_|T2],Y2):- last([3], Z).
T1 = [2,3]
last([X], X). bindet Z=3
T2 = [3]
Y1 = Z
X = 3
Y2 = Z
X = 3 = Z
Anfragen:
© 2011 bei Prof. Dr. Uwe Kastens
© 2013 bei Prof. Dr. Uwe Kastens
weg(X, X).
weg(X, Y):-kante(X, Y).
weg(X, Y):-kante(X, Z), weg(Z, Y).
?-weg(a,c).
prüft, ob es einen Weg von a nach c gibt.
?-weg(a,X).
sucht alle von a erreichbaren Knoten.
?-weg(X,c).
sucht alle Knoten, von denen c erreichbar ist .
Weg der Länge 0
Weg der Länge 1
weitere Weg e
GPS-8-15
GPS-8-14
Beispiel: Symbolische Differentiation
Erläuterungen zur Symbolischen Differentiation
Das folgende Prolog-Programm beschreibt einige einfache Regeln zur Differentiation.
Sie werden auf Terme angewandt, die Ausdrücke beschreiben, und liefern die Ableitung in Form
eines solchen Terms, z. B. ?-diff(2*x,x,D). liefert z. B. D = 2*1+x*0.
Mit weiteren Regeln zur Umformung von Ausdrücken kann das Ergebnis noch vereinfacht
werden.
1. Hier werden Terme konstruiert, z. B. zu 2*x der Term 2*1+x*0
Ausrechnen formuliert man in Prolog durch spezielle IS-Klauseln:
dupl(X,Y):- Y IS X*2.
X muss hier eine gebundene Variable sein.
2. Problemnahe Beschreibung der Differentiationsregeln, z. B. Produktregel:
d(u*v)
=
d x
In Prolog werden Ausdrücke wie 2*x nicht ausgewertet (sofern nicht durch IS explizit
gefordert), sondern als Struktur dargestellt, also etwa *(2, x).
d v
d x
+ v *
d u
d x
3. diff ist definert als Relation über 3 Terme:
diff (abzuleitende Funktion, Name der Veränderlichen, Ableitung)
Prolog-Regeln zur Symbolischen Differentiation:
diff(X, X, 1):- !.
diff(T, X, 0):- atom(T).
diff(T, X, 0):- number(T).
4. Muster in Klauselkopf legen die Anwendbarkeit fest, z. B. Produktregel:
diff(U*V, X, (U*DV)+(V*DU)):- ...
diff(U+V, X, DU+DV):- diff(U, X, DU), diff(V, X, DV).
5. Regeln 1 - 3 definieren:
diff(U-V, X, DU-DV):- diff(U, X, DU), diff(V, X, DV).
d x
= 1
d x
d a
= 0
d x
d 1
= 0
d x
!-Operator (Cut) vermeidet falsche Alternativen.
diff(U*V, X, (U*DV)+(V*DU)):- diff(U, X, DU), diff(V, X, DV).
diff(U/V, X, ((V*DU)-(U*DV))/V*V):- diff(U, X, DU), diff(V, X, DV).
Falls die erste Regel anwendbar ist, bewirkt der Cut (!), dass bei beim Backtracking keine
Alternative dazu versucht wird, obwohl die nächsten beiden Klauseln auch anwendbar wären.
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
u *
6. diff ist eine Relation - nicht eine Funktion!!
?-diff(a+a,a,D).
?-diff(F,a,1+1).
liefert D = 1 + 1
liefert F = a + a
GPS-8-16
GPS-8-17
Beispielrechnung zur Symbolischen Differentiation
?- diff(2*y, y, D)
diff(U*V, X1,(2*DV)+(y*DU)):- diff(2, y, DU),
diff(T1, X2, 0)
:-number(2)
success
Zusammenfassung zum Kapitel 8
diff(y, y, DV)
diff(X3, X3, 1)
:- !
success
Mit den Vorlesungen und Übungen zu Kapitel 8 sollen Sie nun Folgendes
können:
• Kleine typische Beispiele in Prolog-Notation lesen, verstehen und schreiben
liefert Bindungen DU=0 DV=1 D=(2*1)+(y*0)
• Interpretationsschema und prädikatenlogische Grundlagen verstehen
Das Programm kann systematisch erweitert werden, damit Terme nach algebraischen
Rechenregeln vereinfacht werden, z. B.
simp(X*1, X).
simp(X*0, 0).
...
• Unifikation zum Anwenden von Klauseln einsetzen
simp(X+0, X).
simp(X-0, X).
© 2011 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
So einsetzen, dass es auf alle Teilterme angewandt wird.
GPS-9-1
GPS-9-3
9. Zusammenfassung
Zusammenfassung der behandelten Themen
allgemeine Spracheigenschaften:
• Grundsymbole, Syntax, statische Semantik, dynamische Semantik
• kontext-freie Grammatik, Ableitungsbäume, EBNF-Notation, Ausdruckgrammatiken
• Gültigkeit von Definitionen, Verdeckungsregeln
• Variablenbegriff, Lebensdauer, Laufzeitkeller, statischer Vorgänger, Umgebungen
• Datentypen, abstrakte Typkonstruktoren, rekursive und parametrisierte Typen
• konkrete Ausprägungen der abstrakten Typkonstruktoren in Programmiersprachen
• Parameterübergabe: call-by-value, call-by-reference, call-by-result, call-by-value-and-result
Themen dieses Kapitels:
• Zusammenfassung der Themen der Vorlesung
• Zusammenfassung der angestrebten Kompetenzen
© 2005 bei Prof. Dr. Uwe Kastens
© 2009 bei Prof. Dr. Uwe Kastens
Funktionale Programmierung:
• Rekursionsparadigmen: Induktion, Funktionen über rekursiven Datentypen
• Rekursionsformen: End-Rekursion, Zentral-Rekursion,
• Technik „akkumulierender Parameter“, Funktionen über Listen
• Berechnungsschemata mit Funktionen als Parameter; Currying
Logische Programmierung:
• Klauselformen: Fakt, Regel, Anfrage; prädikatenlogische Bedeutung
• Interpretationsschema: Backtracking, Suchreihenfolge
• Unifikation von Termen: Anwendbarkeit von Klauseln, Bindung von Werten an Variable
• Prolog-Notation
GPS-9-4
GPS-9-5
Zusammenfassung der angestrebten Kompetenzen (1)
Zusammenfassung der angestrebten Kompetenzen (2)
1. Einführung
• Wichtige Programmiersprachen zeitlich einordnen
3. Gültigkeit von Definitionen
• Bindung von Bezeichnern verstehen
• Programmiersprachen klassifizieren
• Verdeckungsregeln für die Gültigkeit von Definitionen anwenden
• Sprachdokumente zweckentsprechend anwenden
• Grundbegriffe in den Gültigkeitsregeln von Programmiersprachen erkennen
• Sprachbezogene Werkzeuge kennen
4. Variable, Lebensdauer
• Spracheigenschaften und Programmeigenschaften in die 4 Ebenen einordnen
• Variablenbegriff und Zuweisung
• Zusammenhang zwischen Lebensdauer von Variablen und ihrer Speicherung
• Prinzip des Laufzeitkellers
2. Syntax
• Notation und Rolle der Grundsymbole kennen.
• Besonderheiten des Laufzeitkellers bei geschachtelten Funktionen
• Kontext-freie Grammatiken für praktische Sprachen lesen und verstehen.
• Kontext-freie Grammatiken für einfache Strukturen selbst entwerfen.
können.
• EBNF sinnvoll einsetzen können.
• Abstrakte Syntax als Definition von Strukturbäumen verstehen.
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
• Schemata für Ausdrucksgrammatiken, Folgen und Anweisungsformen anwenden
GPS-9-6
GPS-9-7
Zusammenfassung der angestrebten Kompetenzen (3)
Zusammenfassung der angestrebten Kompetenzen (4)
6. Funktionen, Parameterübergabe
• Funktionen, Aufrufen und Parameterübergabe präzise mit
treffenden Begriffen erklären können
5. Datentypen
5.1 Allgemeine Begriffe zu Datentypen
• Typeigenschaften von Programmiersprachen verstehen und mit
• Die Arten der Parameterübergabe unterscheiden und sinnvoll
treffenden Begriffen korrekt beschreiben
anwenden können
• Mit den abstrakten Konzepten beliebig strukturierte Typen entwerfen
• Die Parameterübergabe wichtiger Sprachen kennen
• Parametrisierung und generische Definition von Typen unterscheiden
und anwenden
7. Funktionale Programmierung
• Funktionale Programme unter Verwendung treffender Begriffe präzise
5.2 Datentypen in Programmiersprachen
erklären
• Ausprägungen der abstrakten Typkonzepte in den Typen von
• Funktionen in einfacher Notation von SML lesen und schreiben
Programmiersprachen erkennen
• Rekursionsparadigmen Induktion, Rekursion über Listen anwenden
• Die Begriffe Klassen, Typen, Objekte, Werte sicher und korrekt
verwenden
• End-Rekursion erkennen und Programmiertechnik „akkumulierender
Parameter“ anwenden
kennen
© 2005 bei Prof. Dr. Uwe Kastens
© 2005 bei Prof. Dr. Uwe Kastens
• Die Vorkommen von Typkonzepten in wichtigen Programmiersprachen
• Speicherung von Reihungen verstehen
GPS-9-8
Zusammenfassung der angestrebten Kompetenzen (5)
8. Logische Programmierung
• Kleine typische Beispiele in Prolog-Notation lesen, verstehen und schreiben
• Interpretationsschema und prädikatenlogische Grundlagen verstehen
• Unifikation zum Anwenden von Klauseln einsetzen
© 2005 bei Prof. Dr. Uwe Kastens
• Anwendungen wie die Symbolische Differentiation verstehen
• Berechnungsschemata mit Funktionen als Parameter anwenden
• Programmiertechnik „Currying“ verstehen und anwenden
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement