Zusammenfassung der 1. Vorlesung

Transkript

1 Zusammenfassung der 1. Vorlesung Informatik oder engl. Computer Science bezieht sich auf ein Gerät, das etwa 50 Jahre alt ist. So alt sind die ersten programmierbaren Rechner: stellvertretend Zuse Z3 oder Eniac. Z3 war mit sog. Relaistechnik realisiert, Eniac benutzte zusätzlich Röhren. Natürlich hatte die Entwicklung hin zum Computer eine Vorgeschichte. Eine ganz wichtige Rolle spielte dabei die Entwicklung eines vernünftigen Zahlensystems (zunächst Dezimalzahlen, später Dualzahlen). Durch den Einsatz eines solchen Zahlensystems wurde der Bau mechanischer Rechenmaschinen praktisch überhaupt erst möglich. Diese Rechenmaschinen waren aber noch nicht programmierbar! Sie konnten nur zum Addieren und Multiplizieren benutzt werden. Erste Vorläufer des Computers im Sinne der Programmierbarkeit waren der sog. Jacquard Webstuhl Hollerith Lochkartenmaschinen Analytical Engine von Babbage Die ersten echten programmierbaren Computer wurden dann im zweiten Weltkrieg entwickelt, wobei das Grundkonzept unserer heutigen Computer auf John von Neumann zurückgeht (1946). (''John von Neumann Architektur''). Diese Computer sind folgendermaßen charakterisiert: Binäre Zahlendarstellungen Elekronische Schaltkreise Programme und Daten in demselben Speicher Seit der Entwicklung des Computers hat man 5 Generationen unterschieden (wobei eine Trennung der Generationen im laufe der Zeit immer schwieriger wird) er Jahre: Röhren-Technologie Additionen pro Sekunde Speicher weniger als 1KByte Programmierung in reiner Maschinensprache 2. bis ca. 65: Transistoren Additionen pro Sekunde mehrere KByte Speicher erste höhere Programmiersprachen und Betriebssysteme 3. bis ca. 75: Transistoren/integrierte Schaltungen bis 1 Mio. Multiplikationen pro Sekunde mehrere 100 KByte Speicher Algol, PL/1, Pascal und Dialogbetriebssysteme 4. bis ca. Ende der 70er Jahre: Mikroprozessoren/Supercomputer (Cray) schnellere Fortschritte in der Hardware als in der Software 5. Höchstintegration

2 Zusammenfassung der 2. Vorlesung Die Fortschritte in den verschiedenen Rechnergenerationen basierten i.w. auf technischen Neuerungen der Hardware-Technologie. Sie führten insbesondere zu einer immer stärkeren Miniaturisierung der Komponenten. Die Architektur an sich -- also der prinzipielle Rechneraufbau hat sich im Laufe der Zeit wenig verändert. (Vergleiche die Fortschritte im Automobilbau in bezug auf den Ottomotor.) Der Hauptspeicher ist im Laufe der Zeit dramatisch billiger geworden. Imselben Maßstab hat sich auch der Sekundärspeicher (Festplatten) etc. verbilligt. Aus technischen Gründen werden alle Daten binär gespeichert. Ein Problem stellt sich nach wie vor bei der Software (ßoftware-Krise''). Die Komplexität unserer heutigen Programmpakete bewegt sich stets an der Grenze dessen, was mit den jeweiligen Programmiermethodologien (Vergehensweisen) noch zu managen ist. Eine gewisse Hilfe sind die sog. höheren Programmiersprachen, die im Laufe der Zeit entwickelt wurden. Unsere derzeitigen Supercomputer sind in der Lage, erstaunlich umfangreiche Stimulationen aus den unterschiedlichsten Erfahrungsbereichen durchzuführen. Letztlich haben diese Erfolge im Extremfall zu der Vorstellung geführt, unser gesamtes Universum könne selbst als Simulation auf einem kosmischen Rechner aufgefaßt werden. (s. z.b. auch Fassbender Film ''Welt am Draht''.) Die Informatik beschäftigt sich nicht nur mit dem Computer als Gerät (''Computer Science''). Sie ist (mindestens) ebenso eine Wissenschaft von Konzepten, deren wichtigster der "Algorithmus" ist. Ein Algorithmus ist zunächst ein schematisches Verfahren zur Lösungsfindung. Eines seiner Kennzeichen ist die Tatsache, daß er ohne Einsicht in seine Richtigkeit benutzt werde kann. Klassisches Beispiel eines Algorithmus ist der euklidsche Algorithmus. (Man findet ihn in jedem Lehrbuch, das nur entfernt etwas mit Algorithmen zu tun hat.) Zusammenfassung der 3. Vorlesung Algorithmen lassen sich im Prinzip aus ganz wenigen Bausteinen zusammensetzen, nämlich aus Folgen von Einzelanweisungen (Sequenzen) Schleifenanweisungen Verzweigungen Dabei ist insbesondere in Hinblick auf die Schleifen dafür zu sorgen, daß ein Algorithmus nicht in einer Endlosschleife hängenbleibt. Der Begriff des Algorithmus wurde erst in der ersten Hälfte dieses Jahrhunderts soweit präzisiert, daß er -- ähnlich wie die Zahlen -- zu einem direkten Objekt der Mathematik wurde. Beachtenswert ist, daß ausnahmslos alle Bemühungen zur Präzisierung des Algorithmus-Begriffes zu äquivalenten Ergebnissen führte. Ein Algorithmus ist nichts anderes als ein Computerprogramm. In der Informatik spielen Definitionen und Beweise durch vollständige Induktion eine große Rolle. Bei der Definition durch vollständige Induktion besteht die Idee darin, die Eigenschaft einer Funktion für die Zahl n allgemein zurückzuführen auf die Eigenschaft dieser Funktion für die Zahl n-1. Die Basis wird dabei gelegt durch direkte Festlegung der Funktion für (typischerweise) 0 oder 1.

3 Zusammenfassung der 4. Vorlesung Objekte, ihre Eigenschaften und ihre Beziehungen sowie ihr Verhalten müssen -- damit Teile der Realität z.b. simuliert werden können -- auf geeignete Programmkonstrukte abgebildet werden (d.h. geeignet durch Programmkonstrukte repräsentiert werden). In einer ersten Näherung unterscheidet man Daten und die sie verarbeitenden Algorithmen Daten werden in unserem täglichen Leben in ganz unterschiedlicher Weise dargestellt: Zahlen mit arabischen Ziffern Texte mit lateinischen Buchstaben Musikstücke mit Hilfe der Noten u.a. Ziffern, Buchstaben und Noten sind Beispiele von Symbol-Mengen, die jeweils zu einem Alphabet zusammengefaßt werden. Prinzipiell lassen sich Zeichenketten, die sich aus Symbolen eines bestimmten Alphabets zusammensetzen, in bestimmter Weise durch Zeichenketten eines anderen Alphabets codieren (Beispiel: Codierung von Texten mit Hilfe des Morse-Alphabets). Ein Alphabet bestehend aus nur zwei Symbolen (zwei Zeichen) wird Binäralphabet genannt. Als Binärzeichen eines Binäralphabets wählt man meistens die Binärziffern 0 und 1. Die Binärziffern nennt man Bits (von binary digits). Durch vollständige Induktion haben wir bewiesen: Es gibt 2 n verschiedene Ziffernfolgen der Länge n, d.h. mit (binären) Ziffernfolgen einer festen Länge n lassen sich maximal 2 n verschiedene Zeichen (eines anderen Alphabets) eindeutig codieren. Dies bedeutet umgekehrt, daß bei einem vorgegebenem Alphabet mit m verschiedenen Zeichen Folgen der Länge log 2 (m) (aufgerundet zur nächsten ganzen Zahl) benötigt werden, um alle m Zeichen des vorgegebenen Alphabets eindeutig mit binären Ziffernfolgen zu codieren. Beispiel: Zur binären Codierung der 10 Ziffern unseres Dezimalsystems benötigen wir also eine Folge von log 2 (10) binären Zeichen (aufgerundet sind das 4 Bits). Mit 8 Bits lassen sich 256 verschiedene Zeichen codieren. (s. ASCII- oder EBCDIC-Tabelle). Zusammenfassung der 5. Vorlesung Daten werden auf dem Computer immer in binärer Form gespeichert. Neben der (binären) Codierung von Zeichen beliebiger Alphabete durch (binäre) Zeichenketten von jeweils festgelegter Länge (wie z.b. der Länge 8 bei der ASCII-Tabelle), lassen sich auch andere in sog. analoger Darstellung vorliegende Informationen wie z.b. Bilder oder Signale leicht in digitalisierte Form überführen. Die Daten, mit denen man es im Zusammenhang mit der EDV in der Regel zu tun hat, lassen sich klassifizieren (also in Typen unterteilen) und zwar in Abhängigkeit davon, welche Operationen auf ihnen erlaubt sind und welche Struktur sie aufweisen. Folgende (elementare) Datentypen können in den höheren Programmiersprachen in der Regel bei der Definition (d.h. Vereinbarung) von Variablen benutzt werden (so daß die definierten Variablen dann nur Werte von diesem Datentyp annehmen können): char (Zeichen) int (ganze Zahlen) float (Fließkommazahlen, d.h. Brüche) boolean (Wahrheitswerte ``wahr'' und ``falsch'')

4 Wie werden die Daten auf dem Rechner gespeichert? Natürlich als Bitfolge. Aber wie werden die Bitfolgen für die Daten jeweils konkret gebildet? Bei den char Daten sind es die Bitkombinationen etwa aus der ASCII-Tabelle. Bei den int Daten sind es die Bitkombinationen, die man aus dem dualen Zahlensystem gewinnt. Die float Daten werden wir noch kennenlernen Die boolean Daten werden i.d.r. durch die ganzen Zahlen 0 und 1 repräsentiert (dadurch braucht man zwar etwas mehr Platz als nötig wäre, was aber in der heutigen Zeit kein Problem mehr darstellt). Zusammenfassung der 6. Vorlesung Die im Rechner zu speichernden Daten werden i.d.r. durch Variablen angesprochen. Die hierzu benutzten Variablennamen werden in den die Daten verarbeitenden Programmen an geeigneter Stelle eingeführt (deklariert). Die Variablen sind bei höheren Programmiersprachen getippt. Variablen können damit immer nur einen Datentyp speichern, also entweder nur Zeichen (char) oder ganze Zahlen (int) oder andere Typen. Gewisse Fehler in der Verarbeitung der Daten lassen sich damit vermeiden. Es gibt einfache Algorithmen, um Zahlen aus einer dezimalen in eine duale Form überzuführen und umgekehrt. Die hexadezimalen Zahlen (basierend auf der Zahl 16 mit entsprechend 16 Ziffern) können als kompaktifizierte Dualzahlen aufgefaßt werden: je 4 Bits (binäre Ziffern) einer Dualzahl entsprechen ein-eindeutig einer hexadezimalen Ziffer und umgekehrt. Insbesondere ist also die Umwandlung von hexadezimalen Zahlen in die entsprechenden Dualzahlen und umgekehrt ziemlich trival. Binäres Zahlensystem ergibt eine einfache Arithmetik, ein einfaches EinmalEins. Zusammenfassung der 7. Vorlesung Die bisherige Darstellung von Zahlen umfaßte ausschließlich den Bereich der nicht-negativen ganzen Zahlen bis zu einer (von der zur Verfügung stehenden Bit-anzahl abhängigen) maximalen oberen Grenze. Im ersten Schritt werden die negativen Zahlen eingeführt in einem zweiten die gebrochenen reellen Zahlen. Die negativen Zahlen werden im sog. 2-er Komplement dargestellt. Dies bedeutet insbesondere, daß die einzelnen Ziffern im Falle negativer Zahlen (und nur in diesem Falle) nicht mehr in der gewohnten Form mit ansteigenden Zweierpotenzen multipliziert werden. Die negativen Zahlen im 2-er Komplement gewinnt man aus den positiven Zahlen durch Austausch der 0-en und 1- en mit nachfolgender Addition einer 1. Ein Überlauf am linken äußeren Ende der Zahl wird dabei nicht mehr berücksichtigt. Die Subtraktion einer (positiven) Zahl wird dabei auf die Addition einer negativen Zahl zurückgeführt. Brüche werden als sog. Fließkommazahlen dargestellt.

5 Zusammenfassung der 8. Vorlesung Die Operation der 2-er Komplementbildung funktioniert in beiden Richtungen. Arithmetische Operationen mit Fließkommazahlen sind i.a. zeitaufwendiger als entsprechende Operationen mit ganzen Zahlen. Arithmetische Operationen werden im Computer durch sog. Logikbausteine realisiert. Der diesen Logikbausteinen zugrunde liegende Logikkalkül ist der Kalkül der klassischen Aussagenlogik. In der klassischen Aussagenlogik hat man es mit 2 sog. Wahrheitswerten -- häufig mit 0 und 1 bezeichnet -- zu tun. Diese Wahrheitswerte können mittels logischer Operationen verknüpft werden. Diese Operationen können, da wir es nur mit 2 Werten zu tun haben, leicht in Tabellenform vollständig beschrieben werden (sog. Wahrheitstabellen). Alternativ können die logischen Operationen mit Hilfe arithmetischer Terme beschrieben werden, indem die Wahrheitswerte kurzfristig wie regelrechte Zahlen gehandhabt werden. Wir erhalten für die betrachteten logischen Operationen damit folgende Darstellungen: A = 1 - A A B = A B A B = A + B - A B Für die logischen Operationen gelten -- analog den arithmetischen Operationen -- eine Reihe von Regeln: Assoziativgesetze Kommutativgesetze Absorptionsgesetze Distributivgesetze Gesetze von demorgan Gesetz der doppelten Verneinung Mit Hilfe dieser Regeln lassen sich logische Terme häufig in eine einfachere Form bringen. Zusammenfassung der 9. und 10. Vorlesung Halten wir uns vor Augen: die logischen Operationen kommen dadurch ins Spiel, daß wir im Rechner binäre Speichermedien haben, die hierbei auftretenden binären Zustände -- in einer Art Doppelrolle -- auch als Wahrheitswerte eines Logikkalküls aufgefaßt werden können, und deshalb die Bit-weisen Operationen im Rechner zwanglos auch als Logikoperationen (Boolesche Operationen) angesehen werden können. Boolesche Operationen sind Funktionen, mit 1 oder 2 Wahrheitswerten als Eingabe und einem Wahrheitswert als Ausgabe. Die booleschen Operationen sind nicht völlig unabhängig: man kann ausgehend von einige wenigen Operationen alle anderen Operationen ausdrücken. Beispiel: Ausgehend von Negation und Disjunktion erhalten wir für andere Operationen: Konjunktion: A B = (A B) Exklusives Oder: A xor B = (A B) (B A) nand: A nand B = (A B) = A B Zweites Beispiel: Ausgehend von nand erhalten wir umgekehrt für alle anderen Operationen: Negation: A = A nand A Disjunktion: A B = (A) nand (B) Die anderen Operationen dann unter Ausnutzung der schon im ersten Beispiel gefundenen Ersetzungen Halten wir also fest, daß wir uns bei der Betrachtung der booleschen Operationen immer auf eine kleine Grundmenge beschränken können, und die anderen uns interessierenden Operationen aus der Grundmenge zusammenbauen können.

6 Inwiefern ist das für uns relevant: Die booleschen Operationen können mit Hilfe elektronischer Bausteine in Form physikalischer Prozesse realisiert werden. Wir können (und müssen) uns dann entscheiden, welche booleschen Operationen wir dann durch elektronische Baugruppen (als Bausteine unserer Grundmenge) gezielt realisieren wollen, und welche anderen Operationen wir dann aus diesen Grundbausteinen zusammensetzen wollen. Wir könnten z.b. den nand-baustein als einzigen Grundbaustein hernehmen, und alle anderen Operationen daraus zusammensetzen. (Man muß sich dann nur ein einziges Mal über die Funktionsweise eines Transistors Gedanken machen, nämlich bei der Verifikation des nand-bausteines.) Es ist letztlich egal, ob jetzt die einzelnen logischen Operationen als elementare Grundbausteine (unserer Grundmenge) realisiert werden oder selbst zusammengesetzt sind aus anderen Grundbausteinen. Damit haben wir unseren ersten Abstraktionsschritt: wir stellen die logischen Operationen durch eigene Symbole dar und kümmern uns nicht mehr darum, wie es intern aussieht. Diese abstraktere Sichtweise kann uns dabei helfen, Schaltungen leichter zu analysieren, z.b. äquivalente Schaltungen zu erkennen. Neben den betrachteten (Halb-)Addierer kann man nun noch sog. Multiplexer und Decoder etc. implementieren, mit denen man spezielle Steuerungen und Zugriffe durchführen kann. Jeder boolesche Ausdruck kann durch elektronische Bausteine in einer 1-1 Weise realisiert werden. Gewisse Gründe wie z.b. das Laufzeitverhalten und Verzögerungen beim eigentlichen Schaltvorgang führen dazu, daß man boolesche Ausdrücke vorzugsweise in gewisse Normalformen überführt (z.b. konjunktive und disjunktive Normalform). Probleme des Taktens von Bausteinen etc. werden in der Informationstechnik behandelt. Zusammenfassung der 11. Vorlesung Die wichtigsten Bestandteile eines Computers sind Speicher Steuerwerk Rechenwerk Sind die Aufgaben des Speichers und des Rechenwerks offensichtlich, so übernimmt das Steuerwerk die Koordination aller Arbeitsabläufe. (Vergleich, Mensch mit Taschenrechner und Papier zum Notieren der Ergebnisse.) In der Regel sind Rechenwerk und Steuerwerk zusammen in einer Baugruppe untergebracht, die CPU (Central Processing Unit) genannt wird. Alle diese Bestandteile bestehen auf der untersten Ebene aus Logikbausteinen, wie sie in den letzten Vorlesungen behandelt wurden. (Speicher aus Flip-Flops, Rechenwerke aus geeignet kombinierten (Halb-)Addieren etc.) Die Datenflüsse zwischen CPU, Speicher und Ein-/Ausgabegeräten laufen heutzutage über Sammelschienen, die man auch Bus nennt. Damit sich die Daten auf dem Bus nicht gegenseitig ins Gehege kommen, wird durch besondere Einrichtungen (wieder aus logischen Bausteinen aufgebaut) dafür gesorgt, daß nicht gleichzeitig mehrere Sender oder Empfänger aktiv sind. (Analogie: akustische Verbindungen durch ein Rohr mit mehreren potentiellen Öffnungen.) Ein Blick auf die peripheren Geräte: Tastaturen Bildschirme Drucker und Plotter Externe Speicher (Disketten, Magnetplatten, optische Platten wie CD-ROMs, Magnetbänder) Modems (z.b. für Verbindungen mit anderen Computern oder mit Sensoren etc.)

7 Zu beachten bei den externen Speichern ist die Tatsache, daß sie nichtflüchtige Speicher darstellen, daß die gespeicherten Daten also bei Stromausfall etc. nicht verlorengehen. Dies macht sie also u.a. für Archivierungszwecke interessant. Für diese Zwecke ist wichtig, daß die Kapazität der externen Speicher hinreichend groß ist. Datenorganisation auf den Magnetplattenspeichern: Spuren Sektoren Zylinder Derzeitige Disketten speichern i.d.r MByte. Disketten mit 2.88 MByte haben sich nicht mehr durchgesetzt. Das ist ein Indiz dafür, daß das Zeitalter der Diskette zu Ende geht, bzw. daß die Einsatzgebiete der Diskette eingeschränkt werden. Statt dessen werden zur Archivierung bzw. zum Datentransfer immer häufiger CD-ROMs (650 MByte) oder sog. Zip-Laufwerke (100 MByte) benutzt. Im Unterschied zu CD-Roms werden die Bits und Bytes nicht auf separaten Spuren (tracks) sondern auf einer Spirale (analog der Schallplatte) angeordnet. Die Daten auf der CD-ROM sind so organisiert, daß viele Ablesefehler automatisch korrigiert werden können. So sind fast die Hälfte aller Bits sog. Prüfbits. Die Bytes selbst sind auf der CD-ROM zusammengefaßt in Gruppen zu je 24 Bytes, die unter Hinzunahme besonderer Bits und Bytes zur Synchronisation einen Rahmen frame bilden. 98 Rahmen bilden einen Block, der die kleinste adressierbare Einheit auf der CD-ROM darstellt. Ein typischer Prozessor besteht (stark) vereinfacht aus: einem sog. Akkumulator (lokale Speichereinheit mit 16 oder 32 Bits zur Zwischenspeicherung von Operanden oder Zwischenergebnissen) einem Befehlsregister (zur Aufnahme des jeweils zur Ausführung kommenden Befehls) einem sog. Befehlszähler (der die Adresse des nächsten auszuführenden Befehls enthält) Der Arbeitszyklus eines Prozessors ist die einer Endlosschleife: 6. Schaue nach, welche Adresse sich im Befehlszähler befindet, gehe an die entsprechende Stelle des Speichers und kopiere den dort stehenden Befehl (d.h. die dort stehende Bitkombination) in das Befehlsregister. 7. Führe den nun im Befehlsregister stehenden Befehl aus. Handelt es sich z.b. um einen Addierbefehl, dann enthält der Addierbefehl selbst eine Adresse, unter der der Operand (i.e. der Summand) sich im Speicher befindet. Es wird in diesem Fall wieder auf den Speicher zugegriffen, diesmal um den Operanden aus ihm zu kopieren. (Hierzu wurde die Adresse benötigt.) Der Operand wird vom Rechenwerk in Empfang genommen mit den Inhalt des Akkumulators addiert und das Ergebnis im Akkumulator zwischengespeichert. (Der alte Inhalt des Akkumulators wird damit überschrieben.) 8. Aktualisiere den Inhalt des Befehlszählers. Im Regelfall bedeutet dies, daß der Befehlszähler um die Länge des alten Befehles erhöht wird, so daß der im Speicher unmittelbar benachbarte Befehl im Anschluß ausgeführt wird. Sollte es sich bei dem letzten Befehl um einen Sprungbefehl gehandelt haben, dann setzt dieser Sprungbefehl von sich aus den neuen Wert (nämlich die Adresse des als nächsten auszuführenden Befehls - - der Sprungbefehl kennt diese Adresse) in den Befehlszähler. 9. Fahre fort mit dem ersten Schritt. Zusammenfassung der 12. Vorlesung Die Maschinenbefehle eines Prozessors lassen sich nach Typen klassifizieren: Transferbefehle (load, store ) Arithmetische Befehle (add, sub) Sprungbefehle (jump, bzw. branch) Maschinenbefehle haben ein bestimmtes Format: sie bestehen (im einfachsten Fall) aus einem Operationsteil (Opcode) und einem Adressteil Der Opcode ist gleichsam der Name des Befehls und muß deshalb aus einer eindeutigen Bitfolge bestehen (d.h. jeder Befehl ist durch eine Bitfolge eindeutig benannt). Die Befehle haben i.d.r. Operanden, also Parameter, die

8 durch den Befehl zu verarbeiten sind. Diese Operanden können Datenelemente im Arbeitsspeicher sein, die dort unter einer speziellen Adresse abgelegt sind. Diese Adresse ist damit Teil des Befehls. Bei Sprungbefehlen besteht der Adressteil nicht aus der Adresse eines zu verarbeitenden Datenelements, sondern aus der Adresse des nächsten auszuführenden Befehls. Sowohl die Befehle als auch die zu verarbeitenden Datenelemente sind im Arbeitsspeicher an geeigneter Stelle abgelegt. In der Anfangszeit der Programmierung wurde die Zuweisung von Adressen (für Befehle und Datenelemente im Arbeitsspeicher) allein vom Programmierer festgelegt. Insbesondere war der Programmierer dafür verantwortlich, daß die Adressteile von Befehlen tatsächlich die richtigen (d.h. die vom Programmierer auch gewollten) Adressen enthielten. Heutzutage übernimmt ein geeigneter Compiler in Zusammenarbeit mit dem jeweiligen Betriebssystem diese Aufgabe, was zur Folge hat, daß eine ganze Reihe von früheren Flüchtigkeitsfehlern jetzt völlig vermieden wird. Nach dem Start eines Programms -- der damit eingeleitet wird, daß der Befehlszähler auf die erste Befehlsadresse des Programms gesetzt wird -- werden die Befehle entsprechend dem Befehlszyklus des Prozessors abgearbeitet. Zusammenfassung der 13. Vorlesung Die von uns beschriebene Maschine (bestehend aus Prozessor und Arbeitsspeicher) ist eine 16-Bit Maschine, d.h. die "Verarbeitungsbreite" (Länge der Dualzahlen, Befehlslänge etc.) beträgt 16 Bit. Die (16-Bit langen) Maschinenbefehle unserer Maschine sind damit so aufgebaut, daß die ersten 4 Bit den Opcode kennzeichnen und die restliche 12 Bit den Adressteil. Damit können wir 16 verschiedene Befehle kennzeichnen und einen Adressbereich von 0 bis 4095 direkt ansprechen. Wir haben jeweils 4 Transferbefehle, arithmetische Befehle und Sprungbefehle. Der load-befehl z.b. hat als Opcode Er kopiert 2 Byte aus dem Arbeitsspeicher in den Akkumulator und zwar diejenigen Bytes im Arbeitsspeicher, deren (Anfangs-)Adresse im Adressteil des load-befehls selbst steht. Der store-befehl operiert sinngemäß in der umgekehrten Richtung (er kopiert also vom Akkumulator in den Arbeitsspeicher hinein). Eine besondere Bedeutung hat der load Byte-Befehl. Er ist der einzige Befehl, der seinen Operanden direkt in seinem Adressteil enthält (so daß der Name "Adressteil" an dieser Stelle etwas mißverständlich ist). Der add-befehl als typischer arithmetischer Befehl operiert wie folgt: Die durch den Adressteil im add-befehl angesprochenen (zwei) Bytes im Arbeitsspeicher werden mit dem Inhalt des Akkumulators (im Rechenwerk des Prozessors) addiert und die Summe wiederum im Akkumulator zwischengespeichert. Bei einem Sprung-Befehl beinhaltet der Adressteil des Befehls die "Sprungadresse", d.h. die die Adresse desjenigen Befehls, der unmittelbar im Anschluß auszuführen ist. Beispiel einer einfachen Befehlssequenz: Kopieren einer Zahl aus dem Hauptspeicher von der Adresse an die Adresse Kopieren der Zahl mit der Adresse aus dem Hauptspeicher ins Register mit load: Kopieren der Zahl aus dem Register in den Hauptspeicher an die Adresse mit store: (zu beachten = ). Die Befehlssequenz zum Kopieren (einer Zahl) von einer Stelle des Arbeitsspeichers in einem anderen hat stets die Form: load ``Ausgangsadresse'' store ``Zieladresse''

9 Zusammenfassung der 14. Vorlesung Betrachten Beispiele von Code-Sequenzen: Kopieren von Speicherplätzen Addieren zweier Datenelemente Vertauschen des Inhalts zweier Speicherplätzen Erweiterung der Rechnerarchitektur: mehrere Register Mehrere Register erlauben das Zwischenspeichern mehrerer Variabler. im Schnitt schnellerer Zugriff auf Variablen. Register werden ähnlich wie Speicherzellen (Bytes) durch eindeutige Adressen angesprochen. (Häufig hat man 16 Register, warum?) Befehle beziehen sich i.a. auf zwei Adressen. Umsetzung Einadressmaschine Zweiadressmaschine. Addition zweier Zahlen: z = x + y Einadressmaschine: 12. load x 13. add y 14. store z Zweiadressmaschine: 1. load R 1 x 2. load R 2 y 3. add Register R 1 R 2 4. store R 1 z (Ein anderes Beispiel findet sich im Buch von Rechenberg.) Zusammenfassung der 15. und 16. Vorlesung Erweiterung der Rechnerarchitektur: indirekte Adressierung Problem: schlechte Verschiebbarkeit eines Programmes im Arbeitsspeicher. Das Programm zur Addition zweier Zahlen ist nicht im Speicher verschiebbar. Lösung durch indirekte Adressierung. Erster Ansatz: Benutzung eines Basisregisters: Opcode R 1 B Adressteil absolute Adresse ergibt sich aus Inhalt von B + Adressteil. Basisregeister erhält Startadresse des Programms, damit ist das Programm im Hauptspeicher leicht verschiebbar. (Man braucht letztlich aber einen Befehl, der das Register beim Programmstart entsprechend setzt. Einen solchen Befehl gibt es in der 370-er Architektur z.b. in Form des BALR-Befehls. Dieser Befehl belegt das angegebene Register mit der nächsten Adresse.) Ein solches zusätzliches Register erlaubte es auch, Schleifen leicht zu programmieren. Beispielprogramm: eine Reihe von Zahlen im Arbeitsspeicher sind zu addieren. (Ohne indirekte Adressierung wären die Befehle -- in diesem Fall der add-befehl -- jeweils während des Programmablaufes selbst zu modifizieren.) load xaddr add yaddr // yaddr bei direkter Adressierung jeweils zu modifizieren store zaddr

10 branch on condition // Sprung zum add-befehl Wenn man beides will, nämlich Verschiebbarket und Index-Adressierung, dann sollte man auch zwei Register im Befehl benutzen. Verkürzung der Befehlslänge: In der ursprünglichen Version relativ lange Maschinenbefehle: 8 Bit (Opcode) + 4 Bit (Registeradresse) + 24 Bit (Adressteil bei 16 MByte Adressraum). Zerlegung des Adressteils in Inhalt eines Indexregister I und in viel kürzeren Adressteil. Befehle erhalten folgendes Format: opcode R 1 I B Adressteil Adressteil ist nur noch 12 Bit lang Befehl ist 32 Bit lang. Resümee: Letztlich haben wir es gleichsam mit einer komplexen Zweiadressmaschine zu tun, wobei das erste Register einfach ein Zielregister ist wie bei der obigen Zweiadressmaschine, das Basisregister der leichteren Verschiebbarkeit des Programmes im Arbeitsspeicher dient, und das Indexregister letztlich der Reduzierung der Befehlslänge dient. Beispiele: load entspricht: lade ins Register 1 das Datenelement, deren Speicheradresse sich wie folgt ergibt: (Inhalt des Registers 2) + (Inhalt des Registers 15) Schreibweise: L 1,512(2,15) add entspricht: addiere zum Inhalt des Registers dasjenige Datenelement, dessen Speicheradresse sich wie folgt ergibt: (wenn Register 0 angegeben ist, dann automatisch 0) + (Inhalt des Registers 2) Schreibweise: A 2,900(0,1) Das Indexregister kann nun natürlich auch leicht dazu benutzt werden, um Schleifendurchläufe zu programmieren, ohne Befehlsmodifikationen zu benutzen. Beispiel: Addiere eine gewisse Anzahl von Zahlen, die im Speicher stehen. Die Anzahl ist selbst ein Wert im Speicher. Zusammenfassung der 17. Vorlesung Einführung eines virtuellen Speicherkonzeptes Die Kosten des Arbeitsspeichers haben sich im Laufe der Zeit drastisch verbilligt. Dennoch sind die externen Speichermedien bezogen auf die Kosten pro Bit um Größenordnungen preisgünstiger. Es lohnt sich damit, die stets vorhandenen Beschränkungen des Arbeitsspeichers dadurch zu überwinden, daß je nach Bedarf Teile des Arbeitsspeicherinhaltes in die externen Speichermedien ausgelagert wird. Der von einem Programm adressierbare Bereich wird damit erweitert, ohne daß der Programmierer dies letztlich bemerken muß. Die Organisation dieses Auslagerns ist Sache des Betriebssystems. Parallelarbeit: Fließbandverarbeitung 15. Befehl ins Befehlsregister 16. Adressteil analysieren 17. Operanden ins Rechenwerk kopieren 18. Befehl ausführen RISC-Architekturen Einfache (gleichlange Befehle) Befehle, Ausführung in einem Takt.

11 Einfacher Prozessor viele Register möglich. Arbeiten mit Fließbandverarbeitung. Parallele Rechnerarchitekturen Mehrfachprozessoren Kommunikation über gemeinsamen Speicher (Sequentialisierung der Zugriffe nötig; eigentliche Zugriffe sind schnell) Kommunikation über Verbindungsleitungen (Versendung von Daten über Verbindungsleitungen dauert lange) Rechnernetze Datenübertragung durch Telefonnetze. Separate Rechner die nicht notwendig an ein und demselben Problem arbeiten. Protokolle für die Datenübertragung. (Protokolle regeln der Datenaufbau und den Ablauf der Kommunikation). Client-Server-Modelle und Verteilte System. Algorithmen -- revisited Haben Algorithmen kennengelernt als Folge von Operationen mit evtl. Schleifen und oder Verzweigungen. Auf der Ebene der Maschinenprogramme haben wir jetzt die Algorithmen kennengelernt als Folge von Maschinenbefehlen, die nacheinander u.u. mit (bedingten) Sprüngen durchgeführt werden. Natürlich lassen sich mit den (bedingten) Sprüngen z.b. Schleifen und Verzweigungen programmieren. Aber nichts hindert einen, mit den Maschinenbefehlen noch ``liberaler'' zu programmieren und ``Spagetti-Code'' zu erzeugen. Warum tun wir das nicht? Aus zwei Gründen: Zur Codierung jedes beliebigen Algorithmus reichen Sequenz, Schleife und Verzweigung aus (so daß auf noch elementarere "gotos" verzichtet werden kann). Das Programmieren mit elementaren "gotos" ergibt einen unübersichtlichen, schwer lesbaren Code. Eine Möglichkeit, Algorithmen übersichtlich aus den Bausteinen Sequenz Verzweigung Schleife aufzubauen, bieten die sog. Struktogramme. Hierin werden die geschilderten Bausteine durch einfache grafische Symbole dargestellt, die sich beliebig schachteln lassen. Aktionen werden durch Rechtecke repräsentiert. Werden diese Aktionen inhaltlich verfeinert, dann entspricht dem eine Verfeinerung auf grafischer Ebene. Beispiel: Bestimmung der Wurzel einer Zahl F. 5. a = 1; b = F/a; 6. falls a - b <, dann a ist Wurzel; andernfalls setze a = (a + b)/2 und b = F/a und wiederhole Schritt 2. Verfeinerung der Operation ``bilde Rest von'': 1. Bilde d = p - q. (Differenz von p und q) 2. Falls d < 0, dann ist p selbst schon Rest, d.h. r = p; andernfalls setze p = d und beginne wieder mit Schritt 1. Betrachtung der Verfeinerungen: Regeln für den Aufbau von Struktogrammen.

12 Zusammenfassung der 18. Vorlesung Wiederholung: Algorithmen können kompliziert oder auch übersichtlich beschrieben werden. Eine Möglichkeit, Algorithmen übersichtlich darzustellen, bilden die sog. Struktogramme. Die Struktogramme bestehen aus drei Bausteinen, die (rekursiv) ineinandergeschachtelt werden können. (Sequenz, Verzweigung, Schleife). Übungen: Lesen der Struktogramme an ausgewählten Beispielen: Negation, Konjunktion und Disjunktion Fakultät Berechnung einer Nullstelle nach Regula Falsi Zusammenfassung der 19. Vorlesung Regeln für den Aufbau von Struktogrammen. Alternative Notation Flußdiagramme. Alternative Regeln für Flußdiagramme. Größere Freiheiten bei Flußdiagrammen. Beispiel eines Flußdiagrammes, das nicht durch Struktogramm ersetzt werden kann. Zugehörige Konstrukte von Programmiersprachen. Zugehörige Grammatik der Programmiersprachen. Umsetzung der Struktogramme in Programme: Negation: Struktogramm / Flußdiagramm C-Programm Maschinenprogramm. Analog Disjunktion Struktogramm Fakultät Programm Struktogramm Regula Falsi Programm Was fehlt noch? Deklarationen der Variablen. Bemerkung zu den Deklarationen. Zusammenfassung der 20. Vorlesung Struktogramme/ Flußdiagramme -> Programme -> Maschinenprogramme Umsetzungen: Zuweisungen und einfache Ausdrücke Sequenzen Verzweigungen Schleifen Struktogramm Regula Falsi Programm (Umsetzung des Struktogramms)

13 (Generelle Idee: Informelle Beschreibung eines Algorithmus -> ) Betrachtung der arithmetischen Ausdrücke. Umsetzung der Ausdrücke in Maschinenbefehle. Was fehlt noch? Deklarationen der Variablen. Bemerkung zu den Deklarationen: Elementare Datentypen zusammengesetzte Datentypen Beispiel: Boolesche Variable wird mit ganzer Zahl addiert. Wie wird das durch die höheren Programmiersprachen verhindert? Deklaration zusammengesetzter Typen in Java C/C++ Zusammenfassung der 21. Vorlesung Wir haben in den letzten Vorlesungen gesehen, wie die Algorithmenbausteine, nämlich Sequenzen Verzweigungen Schleifen in Programmbausteine (also Code, geschrieben in einer höheren Programmiersprache) umgesetzt werden können. Damit allerdings ein lauffähiges Programm entsteht, müssen darüber hinaus noch einige organisatorische Vorbereitungen getroffen werden. Diese Vorbereitungen betreffen einerseits den "Programmkopf": der Beginn des Programmes und evtl. Übergabedaten müssen gekennzeichnet werden. Andererseits müssen die im Programm benutzten Variablen eingeführt, d.h. ``deklariert'' werden: Name und ``Typ'' einer Variablen werden eingeführt. Zusätzlich muß dem Compiler mitgeteilt werden, welche Standard-Hilfsprogramme benutzt werden sollen. Wir wollen uns das ganze an einem einfachen Beispiel ansehen: #include <iostream.h> int main() { int hoehe = 3; int grundseite = 5; double flaeche = hoehe*grundseite*0.5; cout << "Flaeche des Dreiecks:" << flaeche << '\n'; return 0; Es handelt sich hierbei um ein C/C++-Programm. Der Name des Programms ist main. (Der Name des Hauptprogramms ist immer main. Der (Typ-)Bezeichner int vor dem Programmnamen bedeutet, daß das Programm bei seiner Terminierung einen int-wert als Ergebnis zurückliefert. Hierzu findet sich im Programm das Schlüsselwort return in Verbindung mit dem Rückgabewert (in diesem Fall 0). Wenn das Hauptprogramm einen Wert zurückliefert, dann wird dieser Wert vom Betriebssystem in Empfang genommen und weiter verarbeitet. Noch vor dem eigentlichen Beginn des Programms sehen wir eine sog. Compiler-Anweisung in Form von SPMquot#include <iostream.h>''. Auf Grund dieser Anweisung benutzt der Compiler sog. ``Header''-Dateien (das sind Dateien mit der Endung.h), in denen u.a. häufig benutzte Funktionen deklariert sind, die in sog. ``Standard- Bibliotheken'' als fertige Unterprogramme zur Verfügung gestellt werden. In diesem Fall merken wir uns nur, daß wir bei der Benutzung einer Ein/Ausgabefunktion in unserem main Programm etwa mittels des Ausgabeoperators << und des Datenstromobjekts cout die Header-Datei iostream.h angeben müssen. Die Zeile cout << "Flaeche des Dreiecks:" << flaeche << '\n'; ist dann so zu lesen, daß 19. die Zeichenkette Flaeche des Dreiecks: gefolgt von 20. dem Wert der Variable flaeche gefolgt von einem

14 21. Zeilenumbruch (dargestellt durch SPMquot'''', das für die ASCII Bitfolge OA d.h. für das ASCII-Zeichen LF steht) an das ``stream''-objekt cout gesendet wird, das seinerseits der Bildschirmausgabe zugeordnet ist. Wir merken uns hier zunächst einfach: wenn wir aus einem Programm heraus etwas auf dem Bildschirm ausgeben wollen, dann können wir dies mittels der Anweisung cout <<. codieren, müssen hierzu aber zu Anfang die Compiler-Anweisung include <iostream.h> hinschreiben um diese Art der Bildschirmausgabe benutzen zu können. (Es gibt auch noch andere Arten.) Kommen wir damit zu den Variablendeklarationen. In unserem Beispiel werden drei Variablen benutzt, nämlich hoehe, grundseite, flaeche. Dabei haben hoehe und flaeche den Typ int (stehen also für ganze Zahlen) und flaeche hat den Typ float (steht also für eine Fließkommazahl). Die Reihenfolge bei einer Deklaration ist stets `Typ' gefolgt von `Variablenname'. In diesem Beispiel ist gleichzeitig von der Möglichkeit der Variableninitialisierung Gebrauch gemacht worden. Hierunter versteht man die erstmalige Zuweisung eines Anfangswertes an eine Variable unmittelbar nach ihrer Deklaration. Die Initialisierung: int hoehe = 3; kann dabei als Abkürzung für int hoehe; hoehe = 3; aufgefaßt werden. Wir bemerken noch, wie die arithmetische Operationen der Multiplikation in C++ durch einen * dargestellt wird. Das Pendant zu cout ist cin. Mit diesem Datenstromobjekt können umgekehrt Daten mit der Tastatur in ein Programm eingegeben werden. Damit könnte man unser Beispiel-Programm etwas flexibler gestalten, indem man die Werte der Variablen hoehe und grundseite nicht im Programm ein für allemal festlegt sondern über eine Eingabe steuert: cin >> hoehe; cin >> grundseite; Unser Programm könnte damit folgendes Aussehen erhalten: #include <iostream.h> int main() { int hoehe; int grundseite; double flaeche; cin >> hoehe; cin >> grundseite; flaeche = hoehe*grundseite*0.5; cout << "Flaeche des Dreiecks:" << flaeche << '\n'; return 0; Man kann natürlich, um den Dialog noch etwas komfortabler zu gestalten, vor der Eingabe der Werte von hoehe und grundseite entsprechende Eingabeaufforderungen ausgeben: #include <iostream.h> int main() {

15 int hoehe; int grundseite; double flaeche; cout << "Geben Sie den Wert für die Höhe des Dreiecks ein" << '\n'; cin >> hoehe; cout << "Geben Sie den Wert für die Grundseite des Dreiecks ein" << '\n'; cin >> grundseite; flaeche = hoehe*grundseite*0.5; cout << "Flaeche des Dreiecks:" << flaeche << '\n'; return 0; Wir bemerken an dieser Stelle schon, daß der Code für die eigentliche Berechnung immer mehr hinter dem Code zur Benutzerführung zurückzutreten beginnt. (Für heutige Programme ist das ein typisches Phänomen.) Im folgenden betrachten wir ein etwas komplexeres Programm, daß ausgehend von gewissen Eingabewerten, den sog. "effektiven Jahreszins" berechnet: // Programm (prog-3d) zur Berechnung des effektiven Jahreszinses #include <iostream.h> #include <math.h> void main() { float xneg = 1.999; // Anfangswerte für Intervallschachelungsverfahren float xpos = 1.001; float e = ; // gewünschte Genauigkeit float d; // Hilfsvariable für Nullstelle float y; // Hilfsvariable für Funktionswert float s,r,n; float p; cout << "s eingeben " << endl; // Höhe des Kredits cin >> s; cout << "r eingeben " << endl; // Höhe der Monatsraten cin >> r; cout << "n eingeben " << endl; // Anzahl der Monatsraten cin >> n; while (fabs(xpos - xneg) > e) { d = (xneg + xpos)/2; y = r*(1-1/pow(d,n)) - s*(d - 1); cout << "f(d) = " << y << endl; if (y > 0) xpos = d; else xneg = d; cout << "xneg = " << xneg << " " << "xpos = " << xpos << endl; cout << "d= " << d << endl; cout << "Effektiver Jahreszins = " << 100*(pow(d,12) -1) << endl; cout << "s*d hoch n = " << s * pow(d,n) << endl; cout << "r*(d hoch n)/(d-1) = " << r*(pow(d,n) - 1)/(d - 1) << endl; Dasselbe nun mit Hilfe der sog. Unterprogrammtechnik: // Programm (prog-3f) zur Berechnung des effektiven Jahreszinses mit Hilfe eines

16 // Unterprogrammes #include <iostream.h> #include <math.h> float nst(float xpos, float xneg, float e, float s, float r, float n) { float y, d; while (fabs(xpos - xneg) > e) { d = (xneg + xpos)/2; y = r*(1-1/pow(d,n)) - s*(d - 1); if (y > 0) xpos = d; else xneg = d; return d; int main() { float xneg = 1.999; float xpos = 1.001; float e = ; float q; float y; float s,r,n; float p; cout << "s eingeben " << endl; cin >> s; cout << "r eingeben " << endl; cin >> r; cout << "n eingeben " << endl; cin >> n; q = nst(xpos, xneg, e, s, r, n); cout << "Effektiver Jahreszins = " << 100*(pow(q,12) -1) << endl; return 0; Unterprogramme sind typischerweise Programmteile, die immer wiederkehrende Routineaufgaben erledigen, so daß es sich lohnt hierfür einen eigenen Baustein zu konstruieren. Der Aufruf eines Unterprogramms im "Hauptprogramm" erfolgt i.w. durch Hinschreiben des Unterprogrammnamens. Die von dem Unterprogramm benötigten Daten werden i.d.r. mit Hilfe formaler Parameter übergeben. Diese formalen Parameter sind im Unterprogrammkopf deklariert (analog einer Variablendeklaration.) Das aufrufende Programm übergibt die mitzugebenden aktuellen Werte im Anschluß an den Unterprogrammnamen in Klammern. Die mitgegebenen Werte werden dann der Reihe nach den formalen Parametern zugewiesen, so daß dort, wo die formalen Parameter im Unterprogramm benutzt werden, zunächst die aktuell übergebenen Werte benutzt werden. Betrachten wir als vorbereitende Beispiele zwei Programme einmal zur Multiplikation und einmal für die Addition: // Programm zur Multiplikation unter Benutzung schrittweiser Additionen void main() {

17 int faktor1 = 9; int faktor2 = 8; int zwischenerg = 0; int product; while (factor2!= 0){ zwischenerg = zwischenerg + factor1; factor2 = factor2-1; product = zwischenerg; // Programm zur Addition unter Benutzung schrittweiser Additionen mit 1 void main() { int summand1 = 9; int summand2 = 8; int zwischenerg = 0; int summe; while (summand2!= 0){ zwischenerg = zwischenerg + 1; summand2 = summand2-1; summe = zwischenerg; Es besteht nun die Möglichkeit, das zweite Programm zu einem Unterprogramm des ersten Programms umzugestalten. Dazu erhält das Additionsprogramm nun als Unterprogramm einen eigenen Namen (nicht mehr main), etwa addition, wobei zwei formale Parameter für die Übergabe der Summanden vorzusehen sind und ein Ergebnistyp zu spezifizieren ist: // Unterprogramm Addition unter Benutzung schrittweiser Additionen mit 1 int addition(int s1, int s2) { int zwischenerg = 0; int summe; while (s2!= 0){ zwischenerg = zwischenerg + 1; s2 = s2-1; summe = zwischenerg; return summe; Für das Hauptprogramm hätte das nun folgende Konsequenzen: // Programm zur Multiplikation unter Benutzung // des Unterpogramms "addition". void main() { int factor1 = 9; int factor2 = 8; int zwischenerg = 0; int product; while (factor2!= 0){ zwischenerg = addition(zwischenerg,factor1); // zwischenerg = zwischenerg + factor1;

18 factor2 = factor2-1; product = zwischenerg; Frage: Was passiert z.b. mit vom Hauptprogramm an Unterprogramme übergebene Variablen, wenn die übernehmenden formalen Parameter im Unterprogramm neue Werte erhalten? Mehr hierzu später. Zunächst betrachten wir nur Fälle, in denen gewissermaßen nur ``Kopien'' an das Unterprogramm übergeben werden. Was dann im Unterprogramm mit den Kopien passiert, ist für das aufrufende Hauptprogramm mit den darin befindlichen Variablen unerheblich. Bemerkung zu den Deklarationen: Elementare Datentypen zusammengesetzte Datentypen Beispiel: Boolesche Variable wird mit ganzer Zahl addiert. Wie wird das durch die höheren Programmiersprachen verhindert? Deklaration zusammengesetzter Typen in Java C/C++ Zusammenfassung der 22. Vorlesung Unterprogramme Unterprogramme sind typischerweise Programmteile, die immer wiederkehrende Routineaufgaben erledigen, so daß es sich lohnt hierfür einen eigenen Baustein zu konstruieren. (Statt Unterprogramme sagt man häufig auch ``Prozeduren''.) Der Aufruf eines Unterprogramms im "Hauptprogramm" erfolgt i.w. durch Hinschreiben des Unterprogrammnamens. Die von dem Unterprogramm benötigten Daten werden i.d.r. mit Hilfe formaler Parameter übergeben. Diese formalen Parameter sind im Unterprogrammkopf deklariert (analog einer Variablendeklaration.) Das aufrufende Programm übergibt die mitzugebenden aktuellen Werte im Anschluß an den Unterprogrammnamen in Klammern. Die mitgegebenen Werte werden dann der Reihe nach den formalen Parametern zugewiesen, so daß dort, wo die formalen Parameter im Unterprogramm benutzt werden, zunächst die aktuell übergebenen Werte benutzt werden. Betrachten wir als vorbereitende Beispiele zwei Programme einmal zur Multiplikation und einmal für die Addition: // Programm zur Multiplikation unter Benutzung schrittweiser Additionen void main() { int faktor1 = 9; int faktor2 = 8; int zwischenerg = 0; int product; while (factor2!= 0){ zwischenerg = zwischenerg + factor1; factor2 = factor2-1; product = zwischenerg; // Programm zur Addition unter Benutzung schrittweiser Additionen mit 1 void main() { int summand1 = 9; int summand2 = 8;

19 int zwischenerg = summand1; int summe; while (summand2!= 0){ zwischenerg = zwischenerg + 1; summand2 = summand2-1; summe = zwischenerg; Es besteht nun die Möglichkeit, das zweite Programm zu einem Unterprogramm des ersten Programms umzugestalten. Dazu erhält das Additionsprogramm nun als Unterprogramm einen eigenen Namen (nicht mehr main), etwa addition, wobei zwei formale Parameter für die Übergabe der Summanden vorzusehen sind und ein Ergebnistyp zu spezifizieren ist: // Unterprogramm Addition unter Benutzung schrittweiser Additionen mit 1 int addition(int s1, int s2) { int zwischenerg = 0; int summe; while (s2!= 0){ zwischenerg = zwischenerg + 1; s2 = s2-1; summe = zwischenerg; return summe; Für das Hauptprogramm hätte das nun folgende Konsequenzen: // Programm zur Multiplikation unter Benutzung // des Unterpogramms "addition". void main() { int factor1 = 9; int factor2 = 8; int zwischenerg = 0; int product; while (factor2!= 0){ zwischenerg = addition(zwischenerg,factor1); // zwischenerg = zwischenerg + factor1; factor2 = factor2-1; product = zwischenerg; Wir sehen, daß der Aufruf des Unterprogramms auf der rechten Seite einer Zuweisung steht. Das Unterprogramm steht damit für den von ihm zurückgelieferten Wert. Frage: Was passiert z.b. mit vom Hauptprogramm an Unterprogramme übergebene Variablen, wenn die übernehmenden formalen Parameter im Unterprogramm neue Werte erhalten? Mehr hierzu später. Zunächst betrachten wir nur Fälle, in denen gewissermaßen nur ``Kopien'' an das Unterprogramm übergeben werden. Was dann im Unterprogramm mit den Kopien passiert, ist für das aufrufende Hauptprogramm mit den darin befindlichen Variablen unerheblich. Schauen wir uns die mögliche Übersetzung eines solchen Hauptprogramm-/ Unterprogrammpaares in ein Maschinenprogramm an.. Man kann sich auch eine andere Form der Parameterübergabe vorstellen, bei der die übergebenden Variablen nicht als Kopie sondern gewissermaßen im Original übergeben werden. Auf der Ebene der Maschinenprogramme würde

20 das dann wie folgt aussehen. In welchen Fällen ist nun eine solche Form der Parameterübergabe sinnvoll? Betrachten wir hierzu ein Programm zur Vertauschung zweier Zahlen? void compareswap ( int x, int y) { int h; if (x > y) { h = x; x = y; y = h; Wenn in einem (Haupt-)Programm häufig zwei Zahlen zu vergleichen und evtl. umzuordnen sind -- siehe z.b. den Bubble-Sort Algorithmus -- dann böte es sich natürlich an, ein Programm wie das obige swap-programm als Unterprogramm zu benutzen. Im aufrufenden Hauptprogramm würde man vielleicht das ganze dann wie folgt formulieren: void main() { int x1, x2, ; compareswap( x1, x2 ); Bei der bisherigen Art der Parameterübergabe werden aber nur Kopien von x1 und x2 übergeben. Die Kopien werden zwar evtl. vertauscht, nach der Rückkehr ins Hauptprogramm sind allerdings x1 und x2 auf alle Fälle unverändert geblieben. An dieser Stelle ist also der zweite Mechanismus der Parameterübergabe (mittels ``Originalen'') sinnvoll. Um im Unterprogramm festzulegen, daß diese zweite Art der Parameterübergabe gewählt werden soll, wird bei der Deklaration der formalen Parameter im Unterprogrammkopf ein SPMquot&'' benutzt: void compareswap ( int& x, int& y) Bzgl. der Unterprogramme wollen wir noch eine spezielle Art betrachten und zwar die rekursiv aufrufbaren Unterprogramme. Das einfachste Beispiel ist das Unterprogramm zur Berechnung der Fakultät: int fakultaet( int n ) { if( n == 0 ) { return 1; else return n*fakultaet( n - 1 ); Deklarationen von Feldern: int a[] = {1,2,3,4,5,6; Deklaration von Zeigern: int* zi = &i; Zugriff auf den Inhalt: x = *zi;

21 Zusammenfassung der 23. Vorlesung Deklarationen von Feldern: int a[] = {1,2,3,4,5,6; Alternativ (nur in C++, nicht in Java): int a[6] = {1,2,3,4,5,6; int b[6]; // Feldkomponenten nicht initialisiert Mehrdimensionale Felder: int m[][] = { {1, 2, 3, {4, 5, 6 ; \\ Feld mit Feldern als Komponenten \\ 2 Komponenten, jede Komponente \\ hat jeweils wieder 3 Komponenten Alternativ (nur in C++, nicht in Java): int m[2][3] = { {1, 2, 3, {4, 5, 6 ; \\ Feld mit Feldern als Komponenten \\ 2 Komponenten, jede Komponente \\ hat jeweils wieder 3 Komponenten int m[2][3]; // Feldkomponenten nicht initialisiert Ablage eines mehrdimensionalen Feldes im Speicher. Merke: In der Deklaration vor Feldern gibt es einige signifikante Unterschiede zwischen Java und C++: In Java muß die Anzahl der Komponenten in der Deklaration immer weggelassen werden (sie ergibt sich bei der Initialisierung oder später bei der Erzeugung des Objekts). In C++ kann die Anzahl der Komponenten weggelassen werden, wenn das Feld initialisiert wurde. Also: int a[]; // in Java möglich und in C++ unmöglich int a[3]; // in C++ möglich und in Java unmöglich Die einzelnen Komponenten werden über Indizes (beginnend mit 0!) angesprochen: int a[] = {1,2,3,4,5,6; // a[0] == 1; a[1] == 2; a[5] == 6; Analog bei mehrdimensionalen Feldern: int m[][] = { {1, 2, 3, {4, 5, 6 ; // m[0][0] == 1; m[0][1] == 2;. m[1][2] == 6; Analog zu int-feldern lassen sich auch char-felder deklarieren. Aber Achtung: die Behandlung von Strings ist in Java und C++ grundsätzlich noch unterschiedlicher. Neben Feldern lassen sich auch sog. Verbunde (records) deklarieren. Im Gegensatz zu Feldern haben diese zusammengesetzten Datentypen Komponenten von unterschiedlichem Typ. Hierzu kann man sowohl in Java als auch in C++ das class-konzept benutzen. (C++ Gurus wissen, daß man mit class noch sehr viel mehr tun kann, doch lassen wir das hier zunächst einmal beiseite.) Dabei liefert das class-konzept so etwas wie einen neuen Typnamen (vergleichbar int oder char). class KomplexeDaten { public: int komp1; // C++ Syntax char komp2; Die ``reservierten'' Wörter public dienen der Sichtbarmachung der Komponenten, was immer dies bedeuten mag. Wir merken uns hierzu zunächst nur, daß wir public: notieren müssen, wenn wir auf die Komponenten in der nachfolgend geschilderten Weise zugreifen wollen. In Java ist die Syntax ein klein wenig anders: class KomplexeDaten { public int komp1; // Java Syntax public char komp2;

22 In Java fehlt also der Doppelpunkt nach public und zusätzlich muß public vor jede Komponente geschrieben werden. (Die Gründe hierfür lassen wir fürs erste einmal außen vor.) Variablen vom Typ KomplexeDaten lassen sich nun in gewohnter Art deklarieren (zunächst C++ Syntax): KomplexeDaten k; // C++ Der Zugriff auf die einzelnen Komponenten von k geschieht mit Hilfe der sog. Punktnotaton: k.komp1 = 1; // Zuweisung an erste Komponente von k k.komp2 = 'a'; // Zuweisung an zweite Komponente von k Die Deklaration in Java sieht von der Syntax her ein klein wenig anders aus (das hängt damit zusammen, daß in Java komplexe Datenstrukturen stets dynamisch erzeugt werden, und in C++ nicht.) KomplexeDaten k = new KomplexeDaten(); // C++ Der Zugriff ist jedoch in Java wieder vergleichbar zu C++: k.komp1 = 1; // Zuweisung an erste Komponente von k k.komp2 = 'a'; // Zuweisung an zweite Komponente von k Deklaration von Zeigern (nur!!! in C/C++): int i; int* zi = &i; // &i bezeichnet die Adresse von der Variable i Alternativ kann auch eine neuer Speicherplatz dynamisch allokiert werden, auf den der Zeiger dann verweist: int* zi = new int; // es dynamisch ein neuer int angelegt auf den zi veweist Zugriff auf den Inhalt: int x; x = *zi; // weise der Variablen x denjenigen Wert zu, auf den zi verweist. Dynamische Datenstrukturen können in C++ unter Benutzung des Zeigerkonstruktes definiert werden: class DynDat { // dynamische Datenstrukturen in C++ public: int komp1; DynDat* komp2; Auch in Java lassen sich solche dynamischen Datenstrukturen definieren, ohne jedoch explizit das Zeigerkonstrukt benutzen zu müssen. class DynDat { public int komp1; public DynDat komp2; // dynamische Datenstrukturen in Java Graphische Darstellungen solcher verbundenen Listen (linked lists). Konstruktion einer Liste aus DynDat bestehend aus 2 Listenelementen in C++: DynDat dd; // C++ dd.komp2 = new DynDat(); Dasselbe in Java: