Datenabstraktion
Einführung in die Programmierung

• Grundgedanke: Einzelne Dinge werden zu einem neuen Ganzen.
  • Aus 5000 Einzelteilen entsteht ein Auto.
  • Aus zwei Keksen und Schokocreme entsteht ein Waffelkeks.
  • Aus zwei Koordinaten entsteht ein Punkt.
  • Aus einer Menge von Merkmalen entsteht eine Objektstruktur.

• In den bisherigen Beispielen wurden nur Funktionen betrachtet, die atomare Daten (Zahlen) verarbeiten.
• Jetzt rechnen wir mit Punkten in der Ebene

• Sprache: DrRacket-Lehrsprache „Zwischenstufe mit lambda”
• Für die Definition von Strukturen (Verbünde, records) steht die Pseudofunktion define-struct zur Verfügung.
• Punkte im zweidimensionalen, kartesischen Koordinatensystem (s. o.) könnten wie folgt definiert werden: (define-struct point [x y])
• Mit dieser Definition stehen automatisch die folgenden Funktionen bereit:
  • make-point : akzeptiert zwei Zahlen als Argumente und erzeugt ein neues Exemplar der Struktur point.
  • point-x : akzeptiert ein Exemplar der Struktur point und liefert die x-Komponente.
  • point-y : akzeptiert ein Exemplar der Struktur point und liefert die y-Komponente.
  • point? : akzeptiert einen beliebigen Wert als Argument und liefert #true, falls der Wert ein Exemplar der Struktur point ist.

Regel 8 (strukturverarbeitende Funktionen)

1. Bestimme die für die Berechnung des Ergebnisses erforderlichen Komponenten der Datenstruktur!
2. Für jede Komponente der Datenstruktur, von deren Wert das Ergebnis der Funktion abhängt, schreibe den zugehörigen Selektor in die Funktionsschablone.
3. Falls die Funktion eine Datenstruktur als Resultat liefern muss, nimm den Aufruf des Konstruktors in die Schablone mit auf.

• Man beachte, dass Formulierung der Beispielanwendungen für die Funktion add-point die Existenz der Funktion equal-point? voraussetzt.
• Ohne diese Funktion wäre das Aufschreiben der Beispielanwendungen erheblich umständlicher.
• Die Pseudofunktion define-struct erzeugt leider kein Gleichheisprädikat automatisch.
• Racket bietet aber die Möglichkeit Testprozeduren anstelle von Beispielanwendungen zu benutzen.

• Statt des selbst definierten Gleichheitsprädikats equal-point? verwenden wir für den Test die Standard-Testprozedur check-expect.
• check-expect erwartet zwei Argumente:
  1. den zu testenden Ausdruck
  2. den Erwartungswert

;; ein Punkt ist ein Wert
;;   (make-point x y)
;; wobei x und y Zahlen sind und die kartesischen Koordinaten
;; eines Punkts in der Ebene darstellen.
(define-struct point [x y])

;; Berechnung eines neuen Punktes durch die Addition zweier Punkte
(define add-point
  (lambda [p1 p2]
    (make-point
     (+ (point-x p1) (point-x p2))
     (+ (point-y p1) (point-y p2)))))
;; Tests:
(check-expect (add-point (make-point 2 3) (make-point 5 1)) (make-point 7 4))

• Betätigt man nun den Start-Knopf von DrRacket, erscheint im Interaktionsfenster:

Willkommen bei DrRacket, Version 6.7 [3m].
Sprache: Zwischenstufe mit lambda; memory limit: 128 MB.
Der eine Test ist bestanden!
> 

(check-expect expr expr)

Dieser Testfall überprüft, ob der erste expr den gleichen Wert hat wie der zweite expr, wobei das zweite expr meist ein Literal ist.

(check-within expr expr expr)

Wie check-expect, aber mit einem weiteren Ausdruck, der als Wert eine Zahl delta hat. Dieser Testfall überprüft, dass jede Zahl im Resultat des ersten expr maximal um delta von der entsprechenden Zahl im zweiten expr abweicht.

(check-member-of expr expr …)

Ähnlich wie check-expect: Der Testfall überprüft, dass das Resultat des ersten Operanden gleich dem Wert eines der folgenden Operanden ist.

(check-range expr expr expr)

Ähnlich wie check-expect: Alle drei Operanden müssen Zahlen sein. Der Testfall überprüft, ob die erste Zahl zwischen der zweiten und der dritten liegt (inklusive).

(check-error expr expr)

Dieser Testfall überprüft, ob der erste expr einen Fehler produziert, wobei die Fehlermeldung der Zeichenkette entspricht, die der Wert des zweiten expr ist.

Regel 3neu

Schreibe Tests für die Funktion unter Verwendung der check-...-Prozeduren von Racket auf.

Es ist üblich, die Tests zwischen die Zweckbestimmung und die Funktion zu schreiben.

• Funktionen sollen verschiedene – aber verwandte – Datenstrukturen verarbeiten.

• Beispiel: Rechtecke und Kreise sind geometrische Figuren.

      ;; Eine Figur ist entweder
      ;; - ein Rechteck oder
      ;; - ein Kreis
      ;; Name: shape
  

• Für shapes-verarbeitende Funktionen sind nur die Datenstrukturdefinitionen für Rechtecke und Kreise erforderlich.

Regel 9 (Funktionen für gemischte Daten)

1. Wenn sich bei der Datenanalyse herausstellt, dass gemischte Daten zu verarbeiten sind, schreibe zunächst eine Datendefinition in der Form auf:
   ;; Ein \(s\) ist entweder
   ;; - ein \(t_1\) oder
   ;; - \(\ldots\) oder
   ;; - ein \(t_n\)
   ;; Name: x
2. Für eine \(s\) -verarbeitende Funktion ist mindestens je ein Testfall für jede Variante von \(s\) aufzuschreiben.

3. Seien t1?, t2?, …, tn? die Prädikate zu den in \(s\) vorkommenden Varianten \(t_1, t_2, \ldots, t_n\). Dann ergibt sich für eine \(s\) -verarbeitende Funktion die folgende Funktionsschablone:

       (check-... )
       ...
       (check-... )
       (define f
         (lambda [x]
           (cond
              [(t1? x) ...]
              [(t2? x) ...]
              ...
              [(tn? x) ...])))
   

(Aufgaben zu gemischten Daten)