Programmverifikation

Algorithmen und Datenstrukturen 1 

Programmverifikation

Inhalt 

• Korrektheit von Algorithmen 

• Freies Testen mit Debugger 

• Systematisches Testen mit JUnit 

• Logik-Repetition 

• Programmverifikation 

• Java Assertions vs. Exceptions 

• Literatur 

• Wikipedia zum Stichwort Algorithmus: http://de.wikipedia.org/wiki/Algorithmus 

• Kompendium Theoretische Informatik. Ingo Wegener. 

Teubner, 1996. 

Prof. Dr. C. Stamm – Algorithmen und Datenstrukturen 1, FS 12 7-2

Lernziele 

• Der Begriff Programmspezifikation ist Ihnen verständlich und Sie 

wissen wie daraus der Korrektheitsbegriff abgeleitet wird. 

• Sie verstehen den grundsätzlichen Unterschied zwischen dem 

Testen von Programmen und dem formalen Beweisen der 

Korrektheit. 

• Sie sind in der Lage, Programme mit Hilfe von JUnit gezielt auf 

Schwachstellen zu untersuchen und deren Verhalten mit Hilfe eines 

Debugger nachzuvollziehen. 

• Von einfachen Programmen können Sie selber formal beweisen, ob 

sie korrekt sind. 

• Sie können Vor- und Nachbedingungen mit Hilfe von Assertions in 

Java gezielt einsetzen. 


Black and White 

• Gegeben 

• Behälter mit w weissen Kugeln und b schwarzen Kugeln 

• mindestens eine Kugel ist im Behälter: b + w ≥ 1 

• Ablauf (Prozess) 

• solange wenigstens zwei Kugeln im Behälter sind, zufällig zwei Kugeln 

rausnehmen und … 

• haben beide herausgenommenen Kugeln die gleiche Farbe 

eine weisse Kugel in den Behälter legen 

• haben beide herausgenommenen Kugeln unterschiedliche Farben 

schwarze Kugel in den Behälter zurücklegen 

• Gesucht 

• Terminiert dieser Ablauf? 

• Falls ja, wie und wovon hängt die Schlusssituation ab? 


Verbindungslinien 

• Gegeben 

• n schwarze und n weisse Punkte in der Ebene 

• keine drei Punkte kollinear (in einer Reihe) 

• Ablauf 

• je ein weisser und ein schwarzer Punkt werden mit einer Strecke 

verbunden 

• jeder Punkt darf nur mit einem andern Punkt verbunden werden 

• Gesucht 

• Existiert eine schnittfreie Anordnung der Verbindungsstrecken? 

• Falls ja, wie findet man eine solche? 


Korrektheit eines Algorithmus 

• Ein Algorithmus heisst korrekt, wenn er seiner Spezifikation genügt 

wenn er zu allen Eingabedaten, die der Vorbedingung genügen, die 

Ausgabedaten erzeugt, welche die Nachbedingung erfüllen. 

• Die Überprüfung eines Algorithmus hinsichtlich Korrektheit kann auf 

zwei grundsätzlich verschiedene Weisen erfolgen: 

• Verifikation (formale Methode) 

Mittels logischer Herleitungen wird die Einhaltung der Bedingungen an die 

Zwischen- und Endergebnisse des Algorithmus nachgewiesen. 

• Testen (empirische Methode) 

Mit bestimmten ausgesuchten Daten, für die das Ergebnis bekannt ist, wird 

der Algorithmus erprobt. Dabei kann lediglich das Vorhandensein von 

Fehlern entdeckt, nicht jedoch die Fehlerfreiheit nachgewiesen werden. 


Testen 

• Arten von Tests 

• Modul- bzw. Klassentest (Unit-Test) 

• Code-Review (zu zweit den Code Zeile für Zeile besprechen) 

• Systemtest (dem Auftraggeber wird die Funktionsweise des Systems 

demonstriert) 

• Kunst des Testens 

• Programme testen ist nicht einfach 

• in der Praxis werden oft Spezialisten eingesetzt 

• Testen ist nicht billig: Aufwand muss im Verhältnis zur geforderten 

Qualität stehen 

• Fehlerlokalisierung 

• an markanten Stellen des Programms Ausgabeanweisungen einfügen 

(so genannte Kontrollausgaben), um den aktuellen Programmzustand 

zu erfassen 

• Debugger einsetzen 


Testen: Typische Fehler 

• Schleifen, die entweder einmal zu oft oder einmal zu wenig 

durchlaufen werden 

• nicht initialisierte Variablen 

• Bereichsüberschreitung von Variablen 

• Indexüberschreitung bei Arrays 

• Integer-Overflow 

• unerwartete Nebenwirkungen von Methoden 

• bei Verwendung von Instanzvariablen oder globaler Variablen 

• numerische Überraschungen 

• Rundungsfehler 

• Auslöschung führender Ziffern bei Subtraktion ähnlich grosser Zahlen 


Testen: Regeln 

• Wahl von Testdaten 

• Ziel: jede Zeile des Codes muss durchlaufen werden 

• man wähle sowohl typische als auch untypische Eingabewerte 

• besondere Aufmerksamkeit ist auf Sonderfälle (leerer Text, leere Eingabe) und 

Grenzwerte (z.B. kleinster und grösster Wert) zu richten 

• man sollte auch zufällige Testdaten verwenden, selbst wenn diese nicht sinnvoll 

erscheinen mögen, denn mit ihnen lassen sich Testlücken aufgrund scheinbarer 

Selbstverständlichkeiten vermeiden 

• Testdurchführung 

• man notiere vor der Durchführung des Testlaufs, welche Ausgabe das 

Programm laut Spezifikation liefern soll 

• man prüfe nicht nur, ob das Programm tut, was es soll, sondern auch, ob es 

etwas tut, was es nicht soll (z. B.: hat eine Prozedur unerwünschte 

Nebenwirkungen?) 

• Testvereinfachung 

• man entwerfe Algorithmen bzw. Programme testfreundlich 

• man befolge die Grundsätze des strukturierten Programmentwurfs und baue ggf. 

geeignete Testhilfen (z. B. Messpunkte) ein. 


Debugger 

• sehr hilfreiches Werkzeug 

• zur schrittweisen Verfolgung des Kontrollflusses (Programmablauf) 

• zur Inspektion von Variablenwerten während der Laufzeit 

• zur Inspektion des Methoden-Stacks 

• wichtigste Befehle 

• Programm im Debug-Modus starten 

• Breakpoints setzen 

• Programmausführung bis zum nächsten Breakpoint 

• Einzelschrittausführung 

• Methodenaufrufe als Einzelschritt behandeln 

• in Methoden eintauchen 

• aus einer Methode zum Aufruf zurückkehren 

• Variableninspektion 


JUnit 

• sehr hilfreiches Werkzeug 

• zum systematischen Testen einer Java-Unit 

(Klasse oder Methode) 

• zur Zusammenfassung von verschiedenen Unit- 

Tests 

• wichtigste Befehle 

• JUnit-Testklasse erzeugen 

• JUnit-Testmethoden (automatisch) erzeugen 

• Programm als JUnit-Test starten 

• Struktur 

• Testklasse muss von TestCase abgeleitet sein 

• Namen der Testmethoden beginnen mit test 

• Aufruf der Methode fail() signalisiert das nicht 

erfolgreiche Ende eines Tests 


Vor- und Nachbedingungen 

• Vorbedingung (Precondition) 

• ein Algorithmus muss in einem klar definierten Zustand starten, 

andernfalls sind keine klaren Aussagen über seine Arbeitsweise 

möglich 

• alle Parameterwerte des Algorithmus müssen innerhalb der 

spezifizierten Wertebereiche liegen 

• Nachbedingung (Postcondition) 

• die Ausgabe (Endwerte) eines Algorithmus muss der Spezifikation 

entsprechen 

• Beispiel 

• Spezifikation: 

f 

: N N 

x 

[0,10]: 

f ( x) 

 

• Precondition: Parameter x ist ganzzahlig und liegt im Bereich [0,10] 

• Postcondition: f(x) = x! 

x! 


Assertions in Java 

• Assertions sind Zusicherungen 

• dienen zur Überprüfung von Vor- und Nachbedingungen 

• Syntax 

• assert logischerAusdruck; 

• assert logischerAusdruck : "Fehlermeldung"; 

• Semantik 

• ist der logischeAusdruck falsch, dann bricht das Programm ab 

• … und gibt die Fehlermeldung aus 

• Virtual Machine 

• Assertions können ein- und ausgeschaltet werden 

auf Nebeneffekte beim Ausführen der logischen Ausdrücke muss gänzlich 

verzichtet werden 

• standardmässig sind sie ausgeschaltet also heute noch einschalten! 


Assertions: Beispiel 

double method(int param1, int param2) { 

// Vorbedingungen überprüfen 

assert param2 > 100 : "param2 ist zu klein: " + param2; 

assert 0 ≤ param1 && param1 < param2 : "param1 ist falsch"; 

// führe ein paar Berechnungen durch 

double tmp = func(param1, param2); 

// Überprüfung der Nachbedingung 

assert tmp != 0 : "tmp ist null"; 

} 

return tmp; 


Assertions vs. Exception Handling 

• Idee hinter Assertions 

• eine Verletzung einer Assertion hängt nicht … 

• mit ungeschicktem Benutzerverhalten zusammen oder 

• mit einer Ausnahmesituation infolge veränderter Betriebsmittel 

• eine Verletzung einer Assertion ist ein klarer Hinweis auf einen Fehler 

im Programm 

• Assertions erlauben das frühzeitige Erkennen von Programmfehlern 

• Fehler werden bereits in der Testphase und 

• nicht erst beim Benutzer im Einsatz erkannt 

• Idee hinter Exception Handling 

• ungeschicktes Benutzerverhalten elegant abfangen 

• Ausnahmesituation infolge veränderter Betriebsmittel sicher auffangen, 

so dass ein Absturz des Programms vermieden werden kann 


Programmverifikation 

• Entscheidend bei der Verifikation sind 

• Nachweis der erstrebten Nachbedingungen bei erfüllter 

Vorbedingungen 

• Nachweis der Terminierung (ordentlicher Programmabbruch) 

• Auffinden von Schleifeninvarianten 

• Schleifeninvarianten 

• eine Aussageform, die nach jedem Schleifendurchlauf wahr ist, wenn 

sie es vorher war 

• die Idee der Schleifeninvarianten ist häufig gleich der Entwurfsidee, in 

die mathematisches Wissen über den betrachteten Gegenstand eingeht 

• Korrektheit bezüglich Spezifikation 

• Fehler in der Spezifikation werden nicht direkt erkannt 

• die Wahrheit der Schleifeninvarianten und das Zutreffen der 

Abbruchbedingung erlaubt den Schluss, dass die erstrebte 

Nachbedingung erreicht ist, der Algorithmus also tut, was in der 

Spezifikation verlangt wird. 


Probleme der Verifikation 

• umfangreiche Programme 

• modulare bzw. objektorientierte Zerlegung in überblickbare Teile ist 

notwendig 

• manuelle Programmverifikation ist sehr zeitaufwändig 

automatische Verifikationswerkzeuge sind hilfreich 

• Programmspezifikation und Modellvalidierung 

• in der Praxis besteht das eigentliche Problem im Entwickeln eines 

geeigneten Modells (Vereinfachung der Realität) 

• passt das Modell auf die Wirklichkeit? 

• in der Praxis ändert sich die Spezifikation laufend, das Modell wird 

abgewandelt 

angewiesen auf empirisches Testen 


Aussagenlogik: Syntax und Semantik 

• Syntax 

• atomare Formeln (Atome): A, B, C, … 

• seien F und G zwei beliebige Formeln 

• Konjunktion: (F G) ist eine Formel 

• Disjunktion: (F G) ist eine Formel 

• Negation: F ist eine Formel 

• Implikation: (F G) ist eine Kurzschreibweise für (F G) 

• Bikonditional: (F G) ist eine Kurzschreibweise für (F G) (G F) 

• Semantik 

• Belegung B: eine Teilmenge der atomaren Formeln wird mit einem 

Wahrheitswert aus {false, true} bzw. {0,1} belegt 

• die Bedeutungen der Konjunktion, Disjunktion und Negation sind analog 

zur Bool'schen Algebra definiert 

• passende Belegung B auf Formel F angewendet: B(F) 

Prof. Dr. C. Stamm – Algorithmen und Datenstrukturen 1, FS 12 

7-18

Aussagenlogik: Modell und Erfüllbarkeit 

• Modell 

• eine Belegung heisst zu einer Formel F passend, wenn alle in F 

vorkommenden Atome belegt sind 

• eine Belegung B ist ein Modell für eine Formel F, wenn sie passend ist 

und wenn der Wahrheitswert von B(F) = true ist: B ⊨ F 

• Belegung ist B kein Modell für Formel F, wenn sie zwar passend ist, 

aber wenn der Wahrheitswert von B(F) = false ist: B ⊭ F 

• Erfüllbarkeit 

• eine Formel F heisst erfüllbar, wenn für sie ein Modell existiert, 

andernfalls unerfüllbar 

• Tautologie 

• eine Formel F heisst gültig (oder Tautologie), wenn alle passenden 

Belegungen Modelle sind: ⊨ F 

• Bsp.: (F F) 


7-19

Aussagenlogik: Äquivalenz 

Zwei Formeln F und G heissen (semantisch) äquivalent, falls für 

alle passenden Belegungen B gilt: B(F) = B(G). Dafür schreiben wir 

⊨ (F G) oder kurz F ≡ G. 

• Äquivalenzregeln (AND) 

(F F) ≡ F 

(F G) ≡ (G F) 

((F G) H) ≡ (F (G H)) 

(F (F G)) ≡ F 

(F (G H)) ≡ ((F G) (F H)) 

(F G) ≡ (F G) 

(F G) ≡ G, falls ⊨F 

(F G) ≡ F, falls F unerfüllbar 

• Äquivalenzregeln (OR) 

(F F) ≡ F 

(F G) ≡ (G F) 

((F G) H) ≡ (F (G H)) 

(F (F G)) ≡ F 

(F (G H)) ≡ ((F G) (F H)) 

(F G) ≡ (F G) 

(F G) ≡ F, falls ⊨F 

(F G) ≡ G, falls F unerfüllbar 


7-20

Prädikatenlogik 1. Stufe: Syntax 

• Erweiterung der Aussagenlogik um Quantoren, Funktionen, 

Prädikate, Relationen und Variablen 

• nullstellige Prädikate entsprechen den Atomen der Aussagelogik 

• Relationen können als Prädikate aufgefasst werden 

• nullstellige Funktionen sind Konstanten 

• Formeln 

• logische Verknüpfung von Prädikaten 

• die Argumente der Prädikate sind Terme, gebildet aus Funktionen, Variablen 

und Konstanten 

• sei x eine Variable und F eine Formel 

• x F ist eine Formel mit gebundenem x 

• x F ist eine Formel mit gebundenem x 

• eine Formel heisst geschlossen oder Aussage, wenn alle ihre Variablen 

durch Quantoren gebunden sind 

• Prädikatenlogik mit Identität 

• wenn F und G zwei Formeln sind, so ist auch F = G eine Formel 


7-21

Prädikatenlogik 1. Stufe: Semantik 

• Struktur S = (U S , I S ), 

• U S ist eine nicht-leere Grundmenge und I S eine Abbildung 

• der Prädikate über U S 

• der Funktionen auf U S 

• der Variablen auf Elemente von U S 

• Semantik bezüglich passender Struktur S 

• S(Term) 

jeder Term wird gemäss I S auf ein Element aus U S abgebildet 

• S(Prädikat) jedes Prädikat bestimmt einen Wahrheitswert in Abhängigkeit 

seiner Argumente (Terme) 

• S(Formel) die aussagenlogische Verknüpfung der Wahrheitswerte der 

• S(x F) 

Prädikate 

F ist eine Formel 

• ist true, falls für alle d U S gilt: S [x/d] (F) = true 

• ist false, sonst 

• S(x F) F ist eine Formel 

• ist true, falls für ein d U S gilt: S [x/d] (F) = true 

• ist false, sonst 


7-22

Prädikatenlogik: Äquivalenz 

• Definition 

• Zwei prädikatenlogische Formeln F und G sind äquivalent, falls für alle 

passenden Strukturen S gilt: S(F) = S(G). Dafür schreiben wir F ≡ G. 

• Äquivalenzregeln (zusätzlich zur Aussagenlogik) 

x F ≡ x F x F ≡ x F 

x y F ≡ y x F x y F ≡ y x F 

(x F x G) ≡ x (F G) (x F x G) ≡ x (F G) 

falls x in G nicht frei vorkommt, gilt 

(xF G) ≡ x (F G) 

(xF G) ≡ x (F G) 

(xF G) ≡ x (F G) 

(xF G) ≡ x (F G) 


7-23

Formale Programm-Verifikation 

• Tony Hoare 

• Erfinder des Quicksort-Algorithmus 

• Promoter der Idee der Programm-Verifikation mittels Vor- und 

Nachbedingungen 

• Programm: Sequenz von Anweisungen 

• Anweisungen 

• Zuweisung 

• Selektion 

• Rekursion bzw. Iteration 

• Hoare-Triple: { R } P { S } 

• ein Hoare-Triple ist gültig, wenn bei erfüllter Vorbedingung R und nach 

Ausführung von P die Nachbedingung S erfüllt ist 

• das Programm P ist korrekt, wenn das Hoare-Triple gültig ist 


Nachbedingung 

• Variablen 

• Input: a, b, c, …, z 

• Output: a', b', c', …, z' 

• Nachbedingung (Postcondition) 

• je präziser (spezieller), desto besser 

• Implikation {S T} a, b, …, z, a', b', …, z': S T 

• a, b, … z' sind alle Variablen, die in den Nachbedingungen S und T 

vorkommen 

• wenn ein Programm P die speziellere Nachbedingung S erfüllt, so auch die 

allgemeinere T 

• es gibt ein Programm Q, welches die Nachbedingung T erfüllt und 

mindestens so einfach ist wie das Programm P, welches die Nachbedingung 

S erfüllt 

• Beispiele 

S = (x' = 10), T = (x' > 0) 

P 1 = (x' := 6), P 2 = (x' := 10), P 3 = (x' := x + 1) 


Weakest Precondition 

• Vorbedingung (Precondition) 

• damit das Programm P die Nachbedingung (Postcondition) S erfüllen kann, 

muss die Vorbedingung R erfüllt sein 

• je schwächer die Vorbedingung R, desto besser (weniger einschränkender) 

weakest precondition (WP) 

• Beispiel 

Nachbedingung S = (x' = 10) 

Programm P = (x' := x + 2) 

mögliche Vorbedingung R = (a = 0 b = 2 x = 8 z = 0) 

einfachste Vorbedingung (weakest Precondition) WP = (x = 8) 


Ablauf der Verifikation 

• Gegeben 

• Vorbedingung R, Nachbedingung S, Programm P 

• Ablauf 

• aus S und P die schwächste Vorbedingung WP = wp(P, S) berechnen 

• falls { R WP } gilt, dann erfüllt das Programm P die Nachbedingung S 

bei eingehaltener Vorbedingung R 

• R kann somit durch WP ersetzt werden 

• Berechnung der WP 

• ausgehend von der Nachbedingung S 

• Anweisung für Anweisung rückwärts rechnen 

• Berechnungsregeln für Zuweisung, Sequenz, Selektion, Iteration 


WP-Berechnungsregeln: Zuweisung 

• Gegeben 

• Zuweisung P = (x' := y) 

• Nachbedingung S 

• Regel 

• WP = wp(P, S) = wp((x' := y), S) = S| alle x' durch y ersetzt 

• Beispiele 

• S = (a' = z), P = (a' := b + c), WP = (b + c = z) 

• S = (n' = n), P = (n' := n – 1), WP = (n = n – 1) = false 


WP-Berechnungsregeln: Sequenz 

• Gegeben 

• Sequenz P = (Anweisung 1 ; Anweisung 2 ; …; Anweisung n ) 


• Regel 

• WP = wp(P, S) = 

wp((Anweisung 1 ; Anweisung 2 ; …; Anweisung n-1 ), wp(Anweisung n , S)) 

• Beispiel 

P = (t' := x; x' := y; y' := t') 

S = (x' = b y' = a) 

WP = wp((t' := x; x' := y; y' := t'), (x' = b y' = a)) 

= wp((t' := x; x' := y), wp((y' := t'), (x' = b y' = a))) 

= wp((t' := x; x' := y), (x' = b t' = a)) 

= wp((t' := x), wp((x' := y), (x' = b t' = a))) 

= wp((t' := x), (y = b t' = a)) 

= (y = b x = a) 


WP-Berechnungsregeln: Selektion 

• Gegeben 

• logischer Ausdruck b 

• Selektion P = (if b then P 1 else P 2 ) 


• Regel 

• WP = wp(P, S) 

= wp((if b then P 1 else P 2 ), S) = (b wp(P 1 , S)) (b wp(P 2 , S)) 

= (b wp(P 1 , S)) (b wp(P 2 , S)) 

= bb bwp(P 2 , S) bwp(P 1 , S) wp(P 1 , S)wp(P 2 , S) 

= false bwp(P 2 , S) bwp(P 1 , S) false 

= bwp(P 1 , S) bwp(P 2 , S) 


Beispiel: Selektion 

• Gegeben 

• Programm P = (if x < 0 then x' := -x else x' := x – 1) 

• Nachbedingung S = (x' > 0) 

• Gesucht 

• weakest Precondition WP 

WP = wp((if x < 0 x' := -x else x' := x – 1), x' > 0) 

= (x ≥ 0 -x > 0) (x < 0 x – 1 > 0) 

= (x ≥ 0 x < 0) (x < 0 x > 1) 

= true (x [0, 1]) 

= x [0, 1] 

oder 

WP = (x < 0 -x > 0) (x ≥ 0 x – 1 > 0) 

= (x < 0) (x ≥ 0 x > 1) 

= (x < 0) (x > 1) 

= x [0, 1] 


WP-Berechnungsregeln: Iteration 

• Iterationen 

• for-Schleife: Anzahl Durchläufe bekannt als Sequenz betrachten 

• while-Schleife: Spezialfall der Rekursion Invariante bestimmen 

• Gegeben 

• logischer Ausdruck B (so genannte Schleifenbedingung) 

• Programm P = (while B do P 1 ) 

• Nachbedingung S = B INV 

• Invariante (INV) 

• eine logische Bedingung ausgedrückt in den Variablen aus P, welche 

vor P und nach jedem Durchlauf von P 1 gültig ist 

• wenn { INV B } P 1 { INV } gültig ist, so ist auch 

{ INV } while B do P 1 { INV B } gültig 

• Regel 

• WP = wp(P, S) = INV 


Invariante: Beispiel (1) 

• long multiply(int x, int y) { 

long a = x, b = y, r = 0; 

while (a != 0) { 

if ((a & 1) == 1) r += b; 

b = b > 1; 

} 

return r; 

} 

• Nachbedingung 

S = (r = x*y) 

• Invariante 

INV = (a ≥ 0 a*b + r = x*y) 

schwächste Vorbedingung WP 

INV muss gelten 

INV (a ≠ 0) muss gelten 

INV muss gelten 

INV (a = 0) muss gelten 

Nachbedingung S muss gelten 


Fortsetzung des Beispiels (2) 

• Gegeben: Invariante INV = (a ≥ 0 a*b + r = x*y) 

• Gesucht: Ist INV wirklich eine korrekte Invariante? 

• Beweisverfahren 

• wenn an Position die Invariante INV gilt, dann muss an der Position 

auch die Invariante gelten 

• zu zeigen: { (INV B) wp(P 1 , INV) } 

• Beispiel 

R1 = wp(a := a >> 1, INV) = (a/2 ≥ 0 a/2*b + r = x*y) 

R2 = wp(b := b


• Gegeben: Invariante INV = (a ≥ 0 a*b + r = x*y) 

• Gesucht: schwächste Vorbedingung WP 

• Verfahren 

• wenn an Position die Invariante INV gilt, dann gilt sie auch an der 

Position 

• somit ist INV an der Position die Nachbedingung der Instruktionen vor 

der while-Schleife und wir können mit dem üblichen Verfahren WP 

berechnen 

• Beispiel 

R1 = wp(r := 0, INV) = (a ≥ 0 a*b = x*y) 

R2 = wp(b := y, R2) = (a ≥ 0 a*y = x*y) 

WP = wp(a := x, R3) = (x ≥ 0 x*y = x*y) = (x ≥ 0) 



• Gegeben 

• Invariante INV = (a ≥ 0 a*b + r = x*y) 

• Schleifenbedingung B = (a 0) 

• Gesucht: Nachbedingung S 

• Verfahren 

• wenn an Position die Invariante INV gilt, dann gilt an der Position die 

Invariante, nicht aber B, also S = (INV B) 

• Beispiel 

S = (INV B) = (a ≥ 0 a*b + r = x*y a = 0) 

S = (r = x*y a = 0) 

Der Rückgabewert r ist also gleich dem Produkt aus x und y.

Programmverifikation

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?