Skript Informatik Seite 1 von 37
Was ist Informatik? - Informatik ist die Wissenschaft von der systematischen Verarbeitung von Informationen, insbesondere deren automatisierte Verarbeitung mit Hilfe von elektronischen Rechenanlagen. - Die Informatik beschäftigt sich mit: o dem Aufbau, der Arbeitsweise und dem Konstruktionsprinzip von elektronischen Rechenanlagen und o den Strukturen, Eigenschaften und Beschreibungsmöglichkeiten von Informationen und deren Weiterverarbeitung. Seite 2 von 37
Algorithmus - Ein Algorithmus ist eine endliche Folge genau definierter Vorschriften zur Lösung einer Aufgabenstellung. - Ein Algorithmus ist ein Verfahren, welches in einem endlichen Text niedergelegt werden muss und effektiv durch eine Maschine (Computer) ausgeführt werden kann. - Algorithmen wandeln Eingabedaten in Ausgabedaten um. Seite 3 von 37
Programm - Programme sind in einer Programmiersprache formulierte Algorithmen. - Im Gegensatz zu Algorithmen sind Programme in einer eindeutigen Programmiersprache verfasst. - Ein und derselbe Algorithmus kann in verschiedenen Programmiersprachen formuliert werden. Seite 4 von 37
Softwareentwicklung - Unter Softwareentwicklung versteht man die systematische Konstruktion von Programmen zur Lösung eines in der realen Welt gestellten Problems. Seite 5 von 37
Computer - Von wenigen Ausnahmen abgesehen, liegt modernen Computern das Prinzip des Von-Neumann-Rechners zugrunde. - Der Rechner besteht aus fünf Funktionseinheiten: o Steuerwerk o Rechenwerk o Speicher o Eingabewerk o Ausgabewerk - Diese Funktionseinheiten sind durch ein Bussystem verbunden. - Von-Neumann-Rechner folgen dem EVA-Prinzip: Eingabe - Verarbeitung - Ausgabe Seite 6 von 37
Von-Neumann-Rechner Seite 7 von 37
Zentraleinheit - Steuerwerk, Rechenwerk und Speicher fasst man auch unter der Bezeichnung Zentraleinheit zusammen. - Steuerwerk und Rechenwerk sind meist in einem Chip, dem Prozessor (CPU = Central Processing Unit) untergebracht. - Der Prozessor ist mit den anderen Bestandteilen des Rechners über einen Bus verbunden. Seite 8 von 37
Steuerwerk - Das Steuerwerk steuert und koordiniert alle Aktionen, die in der Zentraleinheit ablaufen. - Das Steuerwerk hat folgende Aufgaben: o Befehle in der richtigen Reihenfolge aus dem Speicher laden o Befehle decodieren o Befehle interpretieren o Versorgung der Funktionseinheiten mit Steuersignalen Seite 9 von 37
Rechenwerk - Im Rechenwerk werden die arithmetischen und logischen Verknüpfungen ausgeführt (ALU: Arithmetic Logical Unit). - Die Operanden werden hierbei vom Steuerwerk geliefert. - Das Rechenwerk wird mit den für die richtige Durchführung der Operation notwendigen Steuersignalen versorgt. Seite 10 von 37
Speicher - Im Speicher werden: o Programme o Daten o Zwischenergebnisse o Endergebnisse abgelegt - Jede Speicherzelle hat eine Adresse. Seite 11 von 37
Bus - Ein Rechner ist modular aufgebaut. - Größere Funktionseinheiten sind meist in Form von einzelnen Chips realisiert. - Neben den oben erwähnten Funktionseinheiten gibt es u.a. Chips für die Bildschirmsteuerung, die externe Kommunikation, die Kontrolle von Peripheriegeräten. Seite 12 von 37
Bus - Die notwendigen Verbindungen zwischen den einzelnen Elementen werden von sogenannten Bussen übernommen. - Als Beispiele sind der Datenbus und der Adressbus zu nennen. - Der Datenbus transportiert Daten. - Über den Adressbus wird festgelegt, welche Speicherzelle gelesen oder beschrieben werden soll. Seite 13 von 37
Eingabe- und Ausgabewerk - Geräte, die an dem Ein- und Ausgabewerk angeschlossen sind, werden als Peripherie bezeichnet. - Beispiele für die Peripherie sind: Tastatur, Maus, Bildschirm, Drucker, Scanner, DVD-Laufwerk. - Keine Peripheriegeräte hingegen sind: Konventionelle Festplatten, SSD, USB-Sticks. Sie zählen zu den Datenspeichern. Seite 14 von 37
Programmiersprachen - Man unterscheidet 5 Generationen von Programmiersprachen: o 1. Generation: Maschinensprache o 2. Generation: Assemblersprache o 3. Generation: Höhere Programmiersprache o 4. Generation: Nichtprozedurale Sprache o 5. Generation: Wissens- und Objektorientierte Sprache Seite 15 von 37
Maschinensprache - Die Maschinensprache entspricht dem Befehlsvorrat einer speziellen CPU. - In Maschinensprache geschriebene Programme sind nur auf einem CPU-Typ lauffähig. Seite 16 von 37
Maschinensprache Beispiel 0010 0010 0011 1100 0001 0110 0001 0101 0000 0000 0000 0101 0010 0000 0011 1100 0110 0100 0000 1110 0000 0000 0000 0011 1101 0000 1000 0001 Seite 17 von 37
Assemblersprache - Der Vorrat an symbolischen Befehlen entspricht dem der Maschinensprache. - Einem Maschinenbefehl ist jeweils ein symbolischer Befehl zugeordnet. - In Assembler geschriebene Programme sind nur auf einem CPU-Typ lauffähig. Seite 18 von 37
Assemblersprache - Mit Assembler-Programmen kann man, unter Ausnutzung aller Möglichkeiten der CPU, sehr effiziente Programme erstellen. - Assemblerprogramme werden mit speziellen Übersetzern in Maschinensprache übersetzt. MOVE.L #222222, D0 MOVE.L #333333, D1 ADD.L D1, D0 Seite 19 von 37
Höhere Programmiersprachen - Für diese Sprachen gibt es eine Vielzahl von Bezeichnungen. - Sie sind weitgehend maschinenunabhängig, genormt und oft für einen speziellen Anwendungsbereich konzipiert. - Zur Problemlösung werden Algorithmen formuliert, d.h. die Abfolge, in der die Daten bearbeitet werden, wird definiert. Seite 20 von 37
Höhere Programmiersprachen - Hier trennte sich auch die Entwicklung zwischen Sprachen für kaufmännische Anwendungen, welche meist große Datenbestände verwalten müssen und wissenschaftlichtechnische Anwendungen, bei denen die effiziente Programmierung komplexer mathematischer Algorithmen im Vordergrund steht. Seite 21 von 37
Höhere Programmiersprachen - Als Urahn der kaufmännisch orientierten Programmiersprachen ist COBOL (Common Business Oriented Language, ab 1959) zu sehen; die älteste Programmiersprache für wissenschaftlichtechnische Anwendungen ist FORTRAN (FORmula TRANslator, ab 1954). - Weitere Beispiele sind PL/1, PASCAL, BASIC, ALGOL und C. a = 222222; b = 333333; c = a + b; Seite 22 von 37
Nichtprozedurale Sprachen - Die Definition dieser Sprachen und der im nächsten Unterkapitel beschriebenen Sprachen ist fließend. - Eine wichtige Eigenschaft ist die Nichtprozeduralität. - Dem Rechner muss nicht mehr länger mitgeteilt werden, wie er das Problem zu lösen hat, sondern nur noch, was zu geschehen hat. Seite 23 von 37
Nichtprozedurale Sprachen - Verwendung finden sie überwiegend im Bereich von Dateiverwaltungs- und Datenbanksystemen. - Deshalb werden diese Sprachen auch als datenorientierte Sprachen bezeichnet. - Am bekanntesten ist SQL für die relationale Datenmanipulation. Seite 24 von 37
Nichtprozedurale Sprachen - Die Sprachen der 4. Generation haben die Produktivität in der Programmentwicklung erheblich erhöht. - Allerdings nehmen sie sehr stark Hardwareressourcen in Anspruch. - Viele dieser Sprachen sind proprietär, d.h. sie gehören zu einer bestimmten Rechnerplattform, und damit ist man vom jeweiligen Hersteller abhängig. Seite 25 von 37
Objektorientierte und Wissensbasierte Sprachen - Schwierig ist die Klassifikation dieser Sprachen. - Sie werden teilweise auch als 5. Generation bezeichnet. - Zu bedenken ist jedoch, dass es sich hierbei um die verschiedensten Arten von Programmiersprachen handelt. Seite 26 von 37
Objektorientierte und Wissensbasierte Sprachen - Objektorientierte Sprachen beruhen auf einem vollkommen anderen Programmierprinzip. - Die Daten, die ein Programm verarbeitet und die Methoden, mit denen die Daten verarbeitet werden, werden zu sogenannten Objekten zusammengefasst, die dann miteinander kommunizieren. - Eine wichtige Eigenschaft ist die Möglichkeit der Vererbung von Eigenschaften eines Objektes auf ein anderes. - Beispiele sind C++ und Java. Seite 27 von 37
Objektorientierte und Wissensbasierte Sprachen - Wissensbasierte Sprachen, auch KI-Sprachen (KI = Künstliche Intelligenz) sind Sprachen zur Entwicklung von Expertensystemen. - Beispiele sind LISP und PROLOG. Seite 28 von 37
Übersetzer - Ein grundlegendes Problem aller Programmiersprachen ist die Übersetzung des sogenannten Quellprogramms in Maschinensprache. - Hierbei werden drei Konzepte unterschieden: o Assembler o Compiler o Interpreter Seite 29 von 37
Assembler - Assembler setzen Befehle eins zu eins aus der maschinenorientierten Sprache in die Maschinensprache um. Seite 30 von 37
Compiler - Compiler übersetzen ein in einer höheren Sprache geschriebenes Programm in Maschinensprache. - Dabei wird die Quelldatei auf syntaktische Fehler geprüft. - Nach erfolgreicher Übersetzung und dem Link-Vorgang kann das Programm gestartet werden. - Bei jeder Änderung muss das gesamte Programm neu übersetzt werden. Seite 31 von 37
Interpreter - Interpreter gehen Zeile für Zeile durch den Quelltext. - Eine Zeile wird hierbei auf syntaktische Korrektheit geprüft und dann sofort ausgeführt. - Danach wird die nächste Zeile bearbeitet. - Im Gegensatz zum Compiler erstellt der Interpreter kein eigenes, lauffähiges Programm. - Von daher muss z.b. bei der Weitergabe immer sichergestellt sein, dass der Empfänger auch über den Interpreter verfügt. Seite 32 von 37
Entwicklungsprozess für C++Programme - Der Editor unterstützt den Programmierer bei der Eingabe der Quelldatei z.b. Beispiel.cpp. - Mit dem Präprozessor wird die Quelldatei für den Übersetzungsvorgang vorbereitet. - Der Compiler übersetzt die Quelldatei in Maschinensprache. Als Resultat des erfolgreichen Übersetzungsvorgangs erhält man das Objektprogramm Beispiel.obj. Seite 33 von 37
Entwicklungsprozess für C++Programme - Der Linker fügt dem Objektprogramm andere Objektprogramme, z.b. aus Programm-Bibliotheken hinzu. Es resultiert ein ausführliches Maschinenprogramm Beispiel.exe. - Der Lader transferiert das ausführbare Maschinenprogramm in den Hauptspeicher und startet es. - Der Debugger wird zur Analyse des Quellprogramms und für Tests eingesetzt. Seite 34 von 37
C++ Historie - 1966 Martin Richards entwickelte BCPL, assemblernahe Sprache - 1967 Simula 67, Programmiersprache für mathematisch technische Probleme und Simulation, erste objektorientierte Konzepte - 1970 Ken Thompson entwickelte B, eine assemblernahe Sprache; Unix Betriebssystem für PDP 7-1972 Dennis Ritchie (Bell Labs) entwirft C; rechnerunabhängige Sprache zur Portierung von Unix auf PDP 11 Seite 35 von 37
C++ Historie - 1978 Kernighan und Ritchie geben das erste Referenzbuch zu C heraus - 1979 Start der Arbeiten an C mit Klassen - 1983 erster Entwurf von C++ durch Bjarne Stroustrup; Bell- Labs in den USA - 1985 Bjarne Stroustrup veröffentlicht das Buch: The C++ Programming Language Seite 36 von 37
C++ Historie - 1987 Veröffentlichung des ersten reinen C++ Compilers für PCs und Workstations - 1988 American National Standards Institute (kurz: ANSI) veröffentlicht den ersten C Standard - 1990 erste C++ Version von Borland (heute: Inprise) - 1992 erste C++ Version von Microsoft - 1998 Veröffentlichung des ANSI C++ Standards ISO/IEC 14882 Seite 37 von 37
Kapitel 2 Einführung in C++ Seite 1 von 29
C++ Zeichensatz - Buchstaben: a bis z und A bis Z. - Ziffern: 0 bis 9 - Sonderzeichen: ; :,. # + - * / % _ \! < > & ^ ~ ( ) { } [ ]? Seite 2 von 29
Höhere Elemente - Mit den im Zeichensatz enthaltenen Zeichen werden folgende Elemente gebildet: o Schlüsselwörter o Namen o Konstanten o Operatoren o Interpunktionszeichen Seite 3 von 29
Schlüsselwörter - Schlüsselwörter haben eine durch die Programmiersprache festgelegte Bedeutung. asm auto break case catch char class const continue default delete do double else enum extern float for friend goto if inline int long new operator private protected public register return short signed sizeof static struct switch template this throw try typedef union unsigned virtual void volatile while Seite 4 von 29
Namen - In einem Programm werden Variablen, Funktionen usw. Namen (Bezeichner) zugeordnet. - Ein Name beginnt mit einem Buchstaben oder einem Unterstrich. - Er besteht aus einer Folge von Buchstaben, Ziffern und dem Unterstrich. - Ein Name hat eine vom Compiler abhängige Länge von z.b. 255 Zeichen. Seite 5 von 29
Namen - Groß- und Kleinschreibung wird unterschieden. - Namen von Variablen sollten mit Kleinbuchstaben beginnen. - Konstanten sollten groß geschrieben werden (z.b.: PI). - Ein C++ Schlüsselwort darf nicht als Name verwendet werden. volumen PI _anzahl_werte feldnummer16 FeldNummer16 Seite 6 von 29
Konstanten - Konstanten sind nicht veränderbare Daten innerhalb eines Programms. - Jeder Konstanten ist eindeutig ein Datentyp zugeordnet. - Die spezifische Schreibweise der Konstanten hängt von ihrem Datentyp ab. 3 3.14159 Seite 7 von 29
Operatoren - Operatoren dienen der Verknüpfung von Operanden. - Es sind für jeden Datentyp Operatoren vordefiniert. - Bsp: Addition + Division / Oder Seite 8 von 29
Interpunktionszeichen - Ein Beispiel für ein Interpunktionszeichen ist das Semikolon am Ende jeder Anweisung. a = 1; cin >> radius; Seite 9 von 29
Trennung von Anweisungen - Es können eine oder mehrere Anweisungen in einer Zeile stehen. - Am Ende jeder Anweisung muss ein Semikolon stehen. a = 1; b = 2; c = 3; Seite 10 von 29
Kommentare - C++ Kommentare beginnen mit // und reichen bis zum Ende der Zeile. // Dies ist eine Kommentarzeile a = 1; // Dies ist ein Kommentar Seite 11 von 29
Kommentare - Kommentare im C-Stil sind auch erlaubt, und dienen meist zur vorübergehenden Ausblendung von Programmcode. - Dadurch ist das Ausblenden eines ganzen Abschnittes möglich. /* Dies ist ein Kommentar */ /* volumen = 4.0 / 3.0 * PI * pow(radius, 3); cout << "Volumen = " << volumen << endl; */ Seite 12 von 29
Fortsetzungszeilen - In C++ ist es möglich, eine Zeile in der darauf folgenden Zeile fortzusetzen. volumen = 4.0 / 3.0 * PI * pow(radius, 3); Seite 13 von 29
Leerzeichen - Innerhalb von Schlüsselwörtern, Namen, Konstanten (außer Zeichenkonstanten) und Operatoren (z.b. >>) dürfen keine Leerzeichen verwendet werden. Seite 14 von 29
Das Hallo Welt -Programm Zeile Befehl 1 #include <iostream> 2 using namespace std; 3 void main() 4 { 5 cout << "Hallo Welt "; // Dies ist ein Kommentar 6 } Seite 15 von 29
Das Hallo Welt -Programm - Dieses Programm gibt den Text Hallo Welt auf dem Bildschirm aus. - Ein C++ Programm besteht mindestens aus der globalen Funktion main. Sie ist das Hauptprogramm und darf auch nur main heißen! - In Zeile 1 steht die Präprozessor-Anweisung. - Zeile 2 gibt den Namensraum an, in dem die genutzten Befehle zu finden sind. (Der Befehl cout ist zu finden im Namensraum std ) - Ab Zeile 3 wird die Funktion main definiert. Seite 16 von 29
Das Hallo Welt -Programm - Zeile 4 und 6 begrenzen einen Block. Dieser ist der Funktionsrumpf von main. - Hinter cout << "Hallo Welt"; steht ein Kommentar - Kommentare werden mit // eingeleitet. Alles, was hinter den // folgt, wird nicht abgearbeitet. - Jeder Befehl innerhalb der geschweiften Klammern { } wird durch ein Semikolon abgeschlossen. (Bsp.: cout << "Hallo Welt";) Seite 17 von 29
Das zweite C++-Programm Zeile Befehl 1 #include <iostream> // cin/cout sind hier enthalten 2 #include <cmath> // pow ist hier enthalten 3 using namespace std; 4 void main() 5 { 6 double volumen, radius; 7 const double PI = 3.14159; 8 cout << "Radius der Kugel eingeben: "; 9 cin >> radius; 10 volumen = 4.0 / 3.0 * PI * pow (radius, 3); 11 cout << "Volumen = " << volumen << endl; 12 } Seite 18 von 29
Das zweite C++-Programm - Dieses Programm berechnet das Volumen einer Kugel bei gegebenem Radius. - In Zeile 1 und 2 stehen die Präprozessor-Anweisungen. - In Zeile 3 steht die using-anweisung - Ab Zeile 4 wird die Funktion main definiert. - In Zeile 5 und 12 umschließen den Funktionsrumpf der Funktion main. Seite 19 von 29
Das zweite C++-Programm - In Zeile 6 werden die Variablen volumen und radius definiert. - In Zeile 7 wird die Konstante PI definiert. - In Zeile 8 und 11 werden Zeichenfolgen und der Wert von volumen ausgegeben. - In Zeile 9 steht die Eingabe für die Variable radius. - In Zeile 10 findet man die Berechnung für volumen. - Die vorhandenen // in Zeile 1 und 2 dienen wieder der Einleitung eines Kommentars. Seite 20 von 29
Blöcke - Mit Blöcken fasst man mehrere Befehle und Deklarationen zu einer Einheit zusammen. - Innerhalb eines Blocks können lokale Variablen definiert werden. - Der Rumpf einer Funktion (zum Beispiel bei main) muss ein Block sein. - Blöcke dürfen beliebig ineinander geschachtelt sein. Seite 21 von 29
Blöcke - Beispiel #include <iostream> using namespace std; void main() { int a, b; a = 1; b = 2; cout << a << b << endl; { int b = 5, c = 3; cout << a << b << c << endl; { int d = 4; cout << a << b << c << d << endl; } } } Seite 22 von 29
Header-Dateien - Oberhalb der Funktion main werden Header-Dateien eingebunden. #include <iostream> - Diese, mit Doppelgatter # beginnenden Zeilen, sind sogenannte Präprozessoranweisungen. - Der Präprozessor erzeugt entsprechend der Anweisung den Quelltext, der dann vom Compiler übersetzt wird. - Am Ende einer Präprozessor-Anweisung steht kein Semikolon. Seite 23 von 29
Header-Dateien - Header-Dateien sind Textdateien, die u.a. weitere Befehle enthalten (zb cout, cin). - Header-Dateien werden mit der include-anweisung eingebunden, um diese Befehle im Programm nutzen zu können. Seite 24 von 29
Header-Dateien - Spitze Klammern werden bei Standard-Header-Dateien verwendet. - Zur Einbindung von selbst verfassten Header-Dateien verwendet man Anführungszeichen. #include <math.h> #include "Test.h" Seite 25 von 29
Header-Dateien - Alle in einer Header-Datei deklarierten Namen sind global verfügbar. - Das kann bei großen Programmen zu Namenskonflikten führen. Seite 26 von 29
Header-Dateien - Daher gibt es in C++ z.b. zur Header-Datei math.h noch eine Header-Datei cmath, die dieselben Namen in einem Namensbereich std deklariert. #include <math.h> entspricht #include <cmath> using namespace std; Seite 27 von 29
Formatierungsregeln für Quelldateien - In den obigen Beispielen wurden einige Regeln zur Formatierung eines C++ Quellprogramms befolgt: - Jeder neue Block wird um eine bestimmte Anzahl an Leerzeichen oder Tabs eingerückt. - Blockbegrenzungen stehen immer in einer gesonderten Zeile. - Jede Funktion beginnt mit der ersten Spalte (steht also ganz links). Seite 28 von 29
Formatierungsregeln für Quelldateien - Bei längeren Anweisungen sollte der Übersicht halber nicht mehr, als eine Anweisung pro Zeile geschrieben werden. - Keine Zeile sollte mehr, als 80 Zeichen lang sein, um die Lesbarkeit zu erhöhen. Seite 29 von 29
Kapitel 3 Datentypen und Variablen Seite 1 von 18
Datentypen - Einführung - Für jede Variable muss ein Datentyp festgelegt werden. - Hierdurch werden die Wertemenge und die verwendbaren Operatoren festgelegt. - Für jeden Datentyp gibt es eine Festlegung, in welcher Weise Konstanten eindeutig dargestellt werden können. - In C++ gibt es eine Reihe vordefinierter Datentypen. - Aus den vordefinierten Datentypen können weitere Datentypen zusammengesetzt werden. Seite 2 von 18
Datentypen - Einführung - In dieser Tabelle sind die arithmetischen Datentypen aufgelistet: Datentyp Länge Wertebereich von bis char 1 Byte -2 7 2 7-1 int 4 Byte -2 31 2 31-1 float 4 Byte ± 1.210-38 ± 3.410 +38 double 8 Byte ± 2.210-308 ± 1.810 +308 Seite 3 von 18
Ganzzahlige Konstanten - Ganze Zahlen (ganzzahlige Konstanten) werden unter den Datentyp int gespeichert. - Der Computer speichert die Zahlen aber nicht in der Form, wie wir sie benutzen. (Also z.b. die Zahl 6 wird nicht als "6" gespeichert.) - Die Speicherung erfolgt als Binärzahl. (z.b. 0110 für die Zahl 6) - Um auch negative Zahlen speichern zu können, wird die Zahl bei den meisten Rechenwerken in der Zweierkomplementdarstellung gespeichert. Seite 4 von 18
Ganzzahlige Konstanten Beispiel: 4 wird im Computer so gespeichert: 1. Vorzeichen ignorieren und ins Binärsystem umrechnen 4 => 0000 0100 Seite 5 von 18
Ganzzahlige Konstanten Beispiel: -4 wird im Computer so gespeichert: 1. Vorzeichen ignorieren und ins Binärsystem umrechnen 4 => 0000 0100 2. Invertieren, da negativ 1111 1011 3. Eine 1 addieren, da negativ 1111 1011 + 0000 0001 => 11111100 Seite 6 von 18
Ganzzahlige Konstanten - Durch die Speicherung der Zahlen in Zweierkomplementdarstellung können wir auf dem vorgesehenen Platz zwar nur halb so viele Zahlen speichern. - Jedoch ermöglicht uns dies, dass die Verarbeitung von positiven und negativen Zahlen im Rechenwerk gleich bleiben kann. Ansonsten müsste der Computer bei Berechnungen positive und negative Zahlen intern unterschiedlich behandeln. Seite 7 von 18
Ganzzahlige Konstanten - Eingabe - Ganzzahlige Konstanten können dezimal, oktal oder hexadezimal in einem C-Programm angegeben werden. - Die Unterscheidung wird anhand der ersten Ziffer vorgenommen. Darstellung 1. Ziffer Beispiel dezimal 1 bis 9 4 +4-67 101 oktal 0 012 +0167-013 hexadezimal 0x 0xC2-0x3D Seite 8 von 18
Beispiel #include <iostream> using namespace std; void main () { cout << 10; cout << 012; cout << 0xa; } 10 10 10 Seite 9 von 18
Ganzzahlige Konstanten - Ausgabe - Ganzzahlige Konstanten können dezimal, oktal oder hexadezimal ausgegeben werden. - Die Darstellung wird bestimmt durch den Befehl setbase(). Seite 10 von 18
Beispiel #include <iostream> #include <iomanip> using namespace std; void main () { int var = 10; cout << "Die Zahl " << var << " ist" << endl cout << "hexadezimal: " << setbase(16) << var << endl; cout << "oktal: " << setbase(8) << var << endl; cout << "dezimal: " << setbase(10) << var << endl; } Die Zahl 10 ist hexadezimal: a oktal: 12 dezimal: 10 Seite 11 von 18
Zahlensysteme - Umwandlung einer Dualzahl in eine Dezimalzahl: (010111) 2 = 0 2 5 +1 2 4 +0 2 3 +1 2 2 +1 2 1 +1 2 0 = (23) 10 - Umwandlung einer Oktalzahl in eine Dezimalzahl: (167) 8 = (1 8 2 +6 8 1 +7 8 0 ) = (119) 10 - Umwandlung einer Hexadezimalzahl in eine Dezimalzahl: (C2) 16 = (12 16 1 +2 16 0 ) = (194) 10 Seite 12 von 18
Gleitkomma Konstanten - Der Standarddatentyp für Gleitkomma Konstanten ist double. - Die Abspeicherung erfolgt im IEEE-Format (Institute of Electrical and Electronics Engineers) durch Verwendung: eines Vorzeichenbits, 11 Exponentenbits und 52 Mantissenbits. - Die Genauigkeit der Darstellung ist auf ca. 15 Stellen begrenzt. Seite 13 von 18
Gleitkomma Konstanten - Beispiele für die Ein- und Ausgabe von Gleitkomma Konstanten (Gleitkommazahlen) 1.2345-0.012 41.0 1.1E+02-25.0E+15 Seite 14 von 18
Definition einer Variablen - Bei der Definition einer Variablen wird der Variablen eine Speicherstelle zugewiesen. Diese kann beschrieben und ausgelesen werden. int anzahl; double kraft; double volumen, radius; Seite 15 von 18
Gültigkeitsbereich von Variablen - Variablen können innerhalb und außerhalb von Blöcken deklariert werden. - Wird eine Variable innerhalb eines Blocks deklariert, so hat sie nur hier Gültigkeit. Man nennt sie deshalb eine lokale Variable. - Wird eine Variable außerhalb eines Blocks, d.h. außerhalb von Funktionsrümpfen deklariert, so hat sie von ihrer Position an Gültigkeit. Sie wird globale Variable genannt. Seite 16 von 18
Initialisierung von Variablen - Man kann Variablen auch definierte Anfangswerte zuordnen. - Eine Variable sollte vor ihrer ersten Verwendung initialisiert werden. int anzahl = 1000; double PI = 3.14159; int a = 2, b = 3; Seite 17 von 18
Benannte Konstanten - Konstanten kann ein Name zugeordnet werden. - Wird bei der Initialisierung einer Variablen vor den Datentyp das Schlüsselwort const geschrieben, so handelt es sich um eine benannte Konstante. const double PI = 3.14159; Seite 18 von 18
1 Kapitel 4 Ein- & Ausgabe Seite 1 von 16
1 Ein- und Ausgabe - Für die Ausgabe auf die Standardausgabe (üblicherweise der Monitor) kann das Ausgabe-Objekt cout verwendet werden. - Für die Eingabe vom Standardeingabegerät (Tastatur) wird das Eingabe-Objekt cin verwendet. Seite 2 von 16
1 Ausgabe - cout - Beispiele: cout << "Texteingabe"; cout << x; cout << a << b; cout << c << d << endl; cout << "y = " << y << endl; Seite 3 von 16
1 Ausgabe - cout - Am Ende einer cout-anweisung wird kein automatischer Zeilenvorschub eingefügt. Dies erreicht man durch Einfügen des Manipulators endl in den Ausgabestream. - Bei der Ausgabe einer arithmetischen Größe werden so viele Stellen wie benötigt ausgegeben. - Bei der Ausgabe von Gleitkommazahlen werden diese in Abhängigkeit von ihrem Wert mit oder ohne Exponenten ausgegeben. Seite 4 von 16
1 Ausgabe-Manipulatoren - Die Breite des Ausgabefeldes kann mit dem Manipulator setw(n) beeinflusst werden. - n gibt die Anzahl der Stellen des Ausgabefeldes an. - Dieser Manipulator wirkt nur auf die direkt folgende Ausgabe und gilt für alle Datentypen. cout << "12345678901234567890"; cout << setw(15) << 1.602E-19 12345678901234567890 1.602e-019 Seite 5 von 16
1 Ausgabe-Manipulatoren - Die Anzahl der signifikanten Stellen bei der Ausgabe kann über den Manipulator setprecision(n) beeinflusst werden. - Der Standardwert für n ist 6. - Die Einstellung bleibt für alle weiteren Ausgaben bestehen! cout << setprecision(10) << 10.0/3.0 << endl; 12345678901234567890 3.333333333 Seite 6 von 16
1 Ausgabe-Manipulatoren - Zur Verwendung der Manipulatoren muss die Datei iomanip eingebunden werden: #include <iomanip> Seite 7 von 16
1 Ausgabe-Manipulatoren (kompakt) Methode setw(n) Beschreibung Gibt eine Mindestausgabebreite von n Zeichen vor. Die Ausgabe wird rechtsbündig angeschlagen und links mit Leerzeichen aufgefüllt. Die Ausgabebreite wird bei Bedarf kommentarlos überschritten. Gilt nur immer für die nächste Ausgabe! Seite 8 von 16
1 Ausgabe-Manipulatoren (kompakt) Methode setprecision(n) Beschreibung Gibt an, wie viele Stellen einer Zahl ausgegeben werden sollen. (Standardwert für n ist 6.) Gilt für Vor- und Nachkommastellen. Gibt man im Ausgabestrom das Schlüsselwort "fixed" an, so gilt n nur für die Nachkommastellen. setprecision gilt für alle nachfolgenden Ausgaben. Seite 9 von 16
1 Eingabe - cin - Die Werte der Variablen werden in der Reihenfolge eingegeben, in der sie in der cin-liste aufgeführt sind. - Die Werte werden durch Leerzeichen oder durch Return getrennt. Die Eingabe wird mit Return abgeschlossen. double x,y,z; cin >> x >> y >> z; Eingabe: 1.0 2.3 5 Seite 10 von 16
1 Eingabe - cin - Eingabefehler kann man erkennen, indem man sie durch fail abfängt: if (cin.fail()) cout << "Eingabefehler!" << endl; Seite 11 von 16
1 Escape-Sequenzen - Graphisch nicht darstellbare Zeichen können mit Escape- Sequenzen dargestellt werden. - Um sie darzustellen, werden sie als zwei Zeichen geschrieben. - Eingeleitet werden sie mit \. - Sie benötigen aber trotzdem nur ein Byte. Seite 12 von 16
1 Escape-Sequenzen Zeichen Bedeutung \a Klingelzeichen \b Backspace \f Seitenvorschub \n Neue Zeile \r Wagenrücklauf \t Tabulator \0 String-Ende \\ Backslash \ Anführungszeichen \ Hochkomma \xhh Numerischer Wert eines Zeichens hexadezimal Seite 13 von 16
1 Beispiel #include <iostream> using namespace std; void main () { cout << "\tdies ist \n\tein Beispiel \n\tmit "; cout << "Escape-Sequenzen." << "\n"; } Dies ist ein Beispiel mit Escape-Sequenzen. Seite 14 von 16
1 Beispiel #include <iostream> #include <cmath> using namespace std; void main () { double a = 8.8, b = 7.24, c = 5.8; double y; y = a + sqrt(b - c); cout << "y = " << y << endl; } y = 10 Seite 15 von 16
1 Beispiel #include <iostream> #include <cmath> Zahl Wurzel #include <iomanip> 1.357 1.165 using namespace std; 1.821 1.349 void main () 2.092 1.446 { double x = 1.357, y = 1.821, z = 2.092; cout << setprecision(4); cout << "Zahl" << "\t" << "Wurzel" << endl; cout << x << "\t" << sqrt(x) << endl; cout << y << "\t" << sqrt(y) << endl; cout << z << "\t" << sqrt(z) << endl; } Seite 16 von 16
Kapitel 5 Arithmetische Operatoren Seite 1 von 16
Arithmetische Operatoren - Man unterscheidet unäre und binäre Operatoren. - Je nachdem, ob sie auf einen Operanden wirken, oder eine Verknüpfung zweier Operanden bewirken. Seite 2 von 16
Arithmetische Operatoren - Wie die Berechnung durchgeführt wird, entscheiden die Operatoren. - Sind bei der Division beide Operanden ganze Zahlen, ist es eine Ganzzahl-Divison. - Ist bei der Division hingegen mindestens ein Operand eine Gleitpunktzahl, so ist es eine Gleitpunkt-Divison. Seite 3 von 16
Arithmetische Operatoren Operatoren Bedeutung Bemerkung ++ Inkrement unär -- Dekrement unär + Vorzeichen Plus unär - Vorzeichen Minus unär * Multiplikation binär / Division binär % Modulo binär, ganzzahlig + Addition binär - Subtraktion binär Seite 4 von 16
Merkwürdige Ganzzahl-Arithmetik - Es gibt einen Unterschied zwischen dem, was unser Taschenrechner und dem, was der Computer berechnet. Operation Taschenrechner Computer 7/2 3.5 3 1.5 + 7/2 5 4.5 1/2 + 1/2 1.0/2.0 + 1.0/2.0 1/2 + 1.0/2.0 Seite 5 von 16
Operatorenliste Operatoren Auswertrichtung Priorität Bemerkung () [] ->. li -> re hoch Klammer, Indexop, Komponentenop! ~ ++ -- + - * & (Typ) re -> li unäre Operatoren * / % li -> re arithmetische Operatoren + - li -> re arithmetische Operatoren << >> li -> re Shift-Operatoren < <= > >= li -> re Vergleichsoperatoren ==!= li -> re Vergleichsoperatoren & li -> re Bitoperatoren ^ li -> re Bitoperatoren li -> re Bitoperatoren && li -> re logische Operatoren li -> re logische Operatoren?: li -> re Auswahloperator = += -= *= /= %= etc. re -> li Zuweisungsoperator, li -> re niedrig Ausdrucksfolge Seite 6 von 16
Arithmetische Ausdrücke - Ein Ausdruck kann im einfachsten Fall eine Konstante oder eine Variable sein. - Meist handelt es sich aber um eine Berechnung unter Verwendung von Operatoren. 7.2 anzahl a + b + c Seite 7 von 16
Arithmetische Ausdrücke - Vor dem Ausführen einer binären Operation werden die Datentypen der Operanden angeglichen. - Die Anpassung erfolgt in der Weise, dass der kleinere Datentyp auf den größeren Datentyp erweitert wird. - Das Ergebnis hat dann den größeren Datentyp. char -> unsigned char -> short -> int -> unsigned int -> long -> unsigned long -> float -> double -> long double Seite 8 von 16
Arithmetische Ausdrücke - Beispiele Ausdruck 7 + 1.2 8.2 2.0 * 8 16.0 1 / 2 0 9 / 2 4 1.0 / 3 * 6 2.0 2.5 + 3.0 * 2.0 0.5 8.0 2 * 3 % 4 + 1 3 Ergebnis Seite 9 von 16
Arithmetische Wertzuweisung - Einer arithmetischen Variablen kann der Wert eines arithmetischen Ausdrucks zugewiesen werden. - Der Zuweisungsoperator ist das = Zeichen. - Hat die Variable auf der linken Seite des Zuweisungsoperators einen anderen Datentyp als der Ausdruck auf der rechten Seite, so wird die rechte Seite an den Datentyp der linken Seite angeglichen. int i = 1.25 // i = 1 float x = 7.1E+122 // Compiler-Warnung Seite 10 von 16
Arithmetische Wertzuweisung - Eine Wertzuweisung ist selbst wieder ein Ausdruck und liefert den zugewiesenen Wert. z = 12 - ist ein Ausdruck und liefert den Wert 12. x = (y = (z = 12)); x = y = z = 12; Seite 11 von 16
Arithmetische Wertzuweisung Schreibweise Bedeutung x += 1 x = x + 1 x -= 1 x = x -1 x *= 2 x = x * 2 x /= 2 x = x / 2 x %= 2 x = x % 2 x++ Erhöht x nach der Verwendung um 1 ++x Erhöht x vor der Verwendung um 1 x-- Verringert x nach der Verwendung um 1 --x Verringert x vor der Verwendung um 1 Seite 12 von 16
Mathematische Funktionen - In der Standard-Header-Datei cmath sind mathematische Funktionen aufgeführt. y = sqrt(x); z = sin(w); a = pow(2,10); (Wobei Visual C++ bei Einbindung von <iostream> viele, viele weitere Bibliotheken automatisch auch hinzufügt.) Seite 13 von 16
Mathematische Funktionen Funktionsprototyp Bedeutung double sin(double x); Sinus; x im Bogenmaß double cos(double x); Cosinus; x im Bogenmaß double tan(double x); Tangens; x im Bogenmaß double atan(double x); Arkus Tangens liefert Winkel im Bogenmaß double exp(double x); e x double log(double x); ln(x) (für x > 0) double pow(double x, x y (für (x!= 0 oder y > 0) und (x >= 0 double y); oder y ganzzahlig)) double sqrt(double x); Quadratwurzel von x (für x >= 0) double fabs(double x); x Absolutbetrag Seite 14 von 16
Kommaoperator - Mit dem Kommaoperator können dort mehrere Ausdrücke angegeben werden, wo sonst nur ein Ausdruck stehen darf. - Die Ausdrücke werden von links nach rechts ausgewertet. - Der Wert des Kommaoperator-Ausdrucks hat den Wert und den Typ des am weitesten rechts stehenden Einzelausdrucks. Seite 15 von 16
Kommaoperator #include <iostream> using namespace std; void main() { int a, b, c; a = (b = 2, c = 3, b * c); cout << a << endl; } 6 Seite 16 von 16
Kapitel 6 Vergleichsoperatoren Seite 1 von 6
Vergleichsoperatoren - Vergleichsoperatoren liefern als Ergebnis die booleschen Werte true oder false. - In C++ sind true und false die beiden möglichen Werte einer Variablen vom Datentyp bool. - Der Datentyp bool kann zu den arithmetischen Datentypen gezählt werden. x > 10 nenner!= 0 Seite 2 von 6
Vergleichsoperatoren - Vor einem Vergleich werden beide Operanden auf den gleichen Datentyp gebracht. - true wird intern durch den Wert 1 und false durch den Wert 0 abgebildet. - Bei Vergleichsoperationen wird außerdem jeder numerische Wert ungleich 0 als true interpretiert und der Wert 0 als false. if (2) cout << "true" << endl; Ausgabe: true Seite 3 von 6
Vergleichsoperatoren Operator Bedeutung == gleich (2 Gleichheitszeichen!)!= ungleich < kleiner <= kleiner oder gleich > größer >= größer oder gleich Seite 4 von 6
Vergleichsoperatoren - Vor einem Vergleich werden beide Operanden auf den gleichen Datentyp gebracht. bool b; int a = 10; b = a < 1.5; cout << b << endl; Ausgabe: 0 Seite 5 von 6
Logische Operatoren Logische Operatoren && Bedeutung Logisches UND (Konjunktion): liefert true, wenn beide Operanden true sind Logisches ODER (Disjunktion): liefert true, wenn mindestens einer der beiden Operanden true ist! Logisches NICHT (Negation): liefert true, wenn der Operand false ist und liefert false, wenn der Operand true ist Seite 6 von 6
Kapitel 7 Verzweigungen/Bedingungen Seite 1 von 12
Verzweigungen - Verzweigungen werden eingesetzt, wenn eine Befehlsfolge nur unter bestimmten Bedingungen ausgeführt werden soll. - In C/C++ wird dies durch das Konstrukt if/else erreicht. - Sinngemäß bedeutet das if/else Konstrukt: Wenn die Bedingung zutrifft, mache das (Befehlszeilen im if-block). Ansonsten mache etwas anderes (Befehlszeilen im else-block). Seite 2 von 12
if/else -Anweisung - Mit der if/else -Anweisung kann eine von zwei Anweisungen abhängig von einer Bedingung ausgewählt werden. if (x > 10) { cout << "x ist größer als zehn" << endl; } else { cout << "x ist kleiner oder gleich zehn" << endl; } Seite 3 von 12
if/else -Anweisung - Nach dem Schlüsselwort i folgt ein logischer Ausdruck in Klammern. - Liefert der logische Ausdruck den Wert true (ungleich 0), dann wird die if -Anweisung ausgeführt. Im anderen Fall wird die else -Anweisung ausgeführt. Seite 4 von 12
if/else -Anweisung - Wenn eine Anweisungsfolge nur aus einer Anweisung besteht, können die Blockklammern weggelassen werden. if (x > 10) cout << "x ist größer als zehn" << endl; else cout << "x ist kleiner oder gleich zehn" << endl; Seite 5 von 12
if/else -Anweisung Seite 6 von 12
if -Anweisung - Der else -Zweig kann auch entfallen. if (nenner == 0) cout << "Division durch Null!" << endl; Alternative Schreibweise: if (nenner == 0) cout << "Division durch Null!" << endl; Seite 7 von 12
else/if -Anweisung - Mit der else/if -Anweisung können eine oder mehrere weitere Bedingungen eingebunden werden. if (x >= -1 && x <= 1) cout << "x liegt im Intervall [-1,1]" << endl; else if (x > 10) cout << "x ist größer als zehn" << endl; else if (x < 5) cout << "x ist kleiner als 5" << endl; else cout << "x hat den Wert:" << x << endl; Seite 8 von 12
else/if -Anweisung Seite 9 von 12
switch/case -Anweisung - Mit der switch/case Anweisung ist es möglich, mehr als zwei Fälle zu unterscheiden. - Eine Folge von else/if Anweisungen lässt sich auch durch eine switch/case Anweisung realisieren. - Nach jedem case folgt ein konstanter Ausdruck. - Man kann einen sogenannten default-fall einfügen, der abgearbeitet wird, wenn kein anderer Fall zutrifft. Seite 10 von 12
switch/case -Anweisung cin >> zahl switch (zahl) { case 4: cout << "vier"; break; case 5: cout << "fuenf"; break; default: cout << "keine Zahl"; } Seite 11 von 12
switch/case -Anweisung Seite 12 von 12
Kapitel 8 Nassi-Shneiderman-Diagramm (Struktogramm) Seite 1 von 14
Nassi-Shneiderman-Diagramm - auch genannt: Struktogramm - dient der strukturierten Programmierung - reduziert das Gesamtproblem in mehrere Teilprobleme - ist programmiersprachenunabhängig und kann als eine Art Bauplan für das Programm verstanden werden - Jede Anweisung wird durch ein entsprechendes Symbol dargestellt. Seite 2 von 14
Einfache Anweisung - Zur Darstellung einer einzeiligen Anweisung, wie z.b. cout. Seite 3 von 14
Einfache Anweisung - Beispiel int zahl = 3; zahl = zahl % 2; cout << "Die Zahl lautet: " << zahl << endl; Seite 4 von 14
Bedingung if/else - Bei zutreffender Bedingung wird der "ja-fall", ansonsten der "nein-fall" abgearbeitet. Seite 5 von 14
Bedingung if/else - Beispiel if ( zahl == 4 ) // zu prüfende Bedingung { cout << "vier"; // Anweisungsblock 1 } else { cout << "nicht vier"; // Anweisungsblock 2 } Seite 6 von 14
Fallauswahl switch/case - Der Wert der Variablen wird geprüft und daraufhin der zugehörige Anweisungsblock abgearbeitet. - Es kann ein Alternativfall eingefügt werden, falls kein Wert zutrifft (sogenannter default-fall). Seite 7 von 14
Fallauswahl switch/case - Beispiel switch (zahl) // Variable { case 3: // Wert cout << "drei"; // Anweisungsblock 1 break; case 4: cout << "vier"; // Anweisungsblock 2 break; default: // sonst -Fall cout << "falsche Zahl"; break; } Seite 8 von 14
Kopfgesteuerte Schleife - Die Bedingung wird zuerst geprüft. Ist sie wahr, wird der Anweisungsblock abgearbeitet. Seite 9 von 14
Kopfgesteuerte Schleife - Beispiel int zahl = 0; while (zahl < 10) // Bedingung { cout << zahl << endl; // Anweisungsblock zahl++; // Anweisungsblock } Seite 10 von 14
Fußgesteuerte Schleife - Der Anweisungsblock wird ohne Prüfung zunächst einmal abgearbeitet. Danach folgt die Prüfung, ob der Block ein weiteres Mal durchlaufen werden soll. Seite 11 von 14
Fußgesteuerte Schleife - Beispiel int zahl = 0; do { cout << zahl << endl; // Anweisungsblock zahl++; // Anweisungsblock } while (zahl < 10); // Bedingung Seite 12 von 14
Endlos-Schleife - Die Bedingung ist immer wahr. - Die Schleife kann deshalb nur durch ein break verlassen werden. Seite 13 von 14
Endlos-Schleife - Beispiel int zahl = 0; while (true) // Bedingung, die immer gültig ist { cout << zahl << endl; // Anweisungsblock zahl++; // Anweisungsblock } Seite 14 von 14
Kapitel 9 Schleifen Seite 1 von 25
Schleifen - Schleifen werden zur wiederholten Ausführung von Anweisungen verwendet. - Es werden drei Arten von Schleifen unterschieden: o for -Schleife o while -Schleife o do / while -Schleife Seite 2 von 25
Schleifen - Die Anzahl der Schleifendurchläufe wird durch Bedingungen festgelegt. - Bei der for und der while -Schleife stehen die Bedingungen am Beginn der Schleife. - Bei der do / while -Schleife am Ende. Seite 3 von 25
for -Schleife - Ist die Anzahl der Schleifendurchläufe im Voraus bekannt, wird die for -Schleife verwendet. - Die Elemente zur Kontrolle der Schleife werden im Schleifenkopf zusammengefasst. for ([Initialisierung]; [Abbruchbedingung]; [Reinitialisierung]) Anweisung; Seite 4 von 25
for -Schleife - Die Initialisierung erfolgt nur einmal und wird als Erstes vorgenommen. - Die Abbruchbedingung wird zu Beginn jedes Schleifendurchlaufs bewertet. - Ist der Wert der Abbruchbedingung false, wird die Schleife beendet. - Ist der Wert true, wird die Anweisung (Schleifenkörper) ausgeführt und danach die Reinitialisierung durchgeführt. Seite 5 von 25
for -Schleife Ausgabe: 1 3 5 int i; for (i = 1; i <= 5; i+=2) { cout << i << endl; } Seite 6 von 25
for -Schleife Seite 7 von 25
for -Schleife - Ist die Abbruchbedingung schon vor dem Eintritt in die Schleife false, wird der Schleifenkörper nicht durchlaufen. int i, j = 1; for (i = 1; j > 5; i++) cout << i << endl; Seite 8 von 25
for -Schleife - Soll mehr als eine Anweisung zum Schleifenkörper gehören, muss ein Block verwendet werden. int i, j; for (i = 1, j = 5; i <= 5; i += 2, j -= 2) { cout << i << " "; cout << j << endl; } Ausgabe: 1 5 3 3 5 1 Seite 9 von 25
for -Schleife - Die Elemente zur Schleifenkontrolle im Schleifenkopf können auch weggelassen werden. - Bei folgendem Beispiel liegt eine Endlosschleife um eine leere Anweisung vor, da bei fehlender Abbruchbedingung true angenommen wird. for ( ; ; ) ; Seite 10 von 25
for -Schleife - Bei folgendem Beispiel handelt es sich ebenfalls um eine Endlosschleife. - Die Abbruchbedingung ist immer true. int i; for (i = 1; i < 5; i--) cout << i << endl; Seite 11 von 25
for -Schleife - Die Zählvariable kann auch innerhalb des Initialisierungsausdrucks definiert werden. for (int i = 1; i <= 10; i++) Seite 12 von 25
while -Schleife - Die while Schleife wird hauptsächlich verwendet, wenn die Abbruchbedingung erst innerhalb der Schleife festgelegt werden kann. - Es wird vor Eintritt in die Schleife geprüft, ob die Schleife durchlaufen wird. while (Ausdruck) Anweisung - Der Ausdruck kann ganzzahlig oder vom Typ bool sein. - Ist er ganzzahlig, entspricht 0 false und ungleich 0 true. Seite 13 von 25
while -Schleife int i = 0; while (i < 5) cout << ++i; Ausgabe: 12345 Seite 14 von 25
while -Schleife - Das zugehörige Struktogramm sieht wie folgt aus: Seite 15 von 25
do/while -Schleife - Das Abbruchkriterium der do/while Schleife steht am Ende. - Deshalb wird sie mindestens einmal durchlaufen. do Anweisung; while (Ausdruck); - Die Schleife wird durchlaufen, solange der Ausdruck den Wert true hat. - Im Gegensatz zur while Schleife muss am Ende der while -Anweisung ein Semikolon stehen. Seite 16 von 25
do/while -Schleife - In folgendem Beispiel wird die Benutzereingabe wiederholt, bis der eingegebene Wert im Intervall [5, 10] liegt. int i; do cin >> i; while (i < 5 i > 10); Seite 17 von 25
do/while -Schleife - Das zugehörige Struktogramm sieht wie folgt aus: Seite 18 von 25
Geschachtelte Schleifen - Schleifen dürfen ineinander geschachtelt werden. for (int i=1; i<=2; i++) { for (int j=1; j<=2; j++) { cout << i << " " << j << endl; } } Ausgabe: 1 1 1 2 2 1 2 2 Seite 19 von 25
Geschachtelte Schleifen - Das zugehörige Struktogramm sieht wie folgt aus: Seite 20 von 25
break -Anweisung - Die break Anweisung wird verwendet, um eine Schleife unmittelbar zu verlassen. - Bei verschachtelten Schleifen wird nur die aktuelle Schleife verlassen. Seite 21 von 25
continue -Anweisung - Die continue Anweisung wird verwendet, um in einer Schleife unmittelbar die nächste Wiederholung zu beginnen. - In while und do/while Schleifen wird zur Schleifenbedingung gesprungen. - In for Schleifen wird zur Reinitialisierung gesprungen. Seite 22 von 25
Funktion exit - Durch Aufruf der exit Funktion kann ein Programm sofort abgebrochen werden. - Im Fehlerfall übergibt man einen Wert ungleich 0 und bei normaler Beendigung des Programms eine 0. if (i == 3) { cout << "Programm Ende" << endl; exit(0); } Seite 23 von 25
Umformungen - Eine do/while Schleife kann stets in eine while -Schleife umgeformt werden do/while: do { Anweisung; } while (Ausdruck); while: Anweisung; while (Ausdruck) { Anweisung; } Seite 24 von 25
Umformungen - Eine for Schleife kann stets in eine while -Schleife umgeformt werden for (Initialisierung; Abbruchbedingung; Reinitialisierung) Anweisung; Initialisierung; while (Abbruchbedingung) { Anweisung; Reinitialisierung; } Seite 25 von 25
Kapitel 10 Felder / Arrays Seite 1 von 21
Felder - Bisher wurden nur Variablen verwendet, die einen einzelnen Wert aufnehmen können. - Diese Variablen werden auch Skalare genannt. - Aus einer Menge von Skalaren gleichen Datentyps kann man ein Feld (array) bilden. - Die einzelnen Skalare werden dann durch Indizes unterschieden. Seite 2 von 21
Felder - In der Mathematik werden Felder z.b. für die Darstellung von Vektoren und Matrizen verwendet. v = ( v, v2,..., v 1 n ) A = a a... am 11 21 1 a a a 12 22... m2............ a a a 1n 2n... mn - Vektoren sind eindimensionale und Matrizen zweidimensionale Felder. Seite 3 von 21
Definition von Feldern - Jedes Feldelement hat den gleichen Datentyp. Er steht vor dem Feldnamen. - Hinter dem Feldnamen steht die Angabe zur Dimensionierung. - Für jede Dimension wird die Dimensionierung in ein Paar eckige Klammern gesetzt. - Sie gibt die Anzahl der Feldelemente an, die abgespeichert werden können. - Es handelt sich um einen ganzzahligen konstanten Ausdruck. - Der Index einer Dimensionierung beginnt immer mit 0; Seite 4 von 21
Eindimensionale Felder - In folgendem Beispiel wird ein eindimensionales Feld mit dem Namen zahlen definiert. - Das Feld hat 20 Elemente. - Alle Elemente sind vom Datentyp int. - Die Indizes liegen im Bereich von 0 bis 19. int zahlen[20]; Seite 5 von 21
Eindimensionale Felder - In folgendem Beispiel wird ein eindimensionales Feld mit dem Namen werte definiert. - Das Feld hat 10 Elemente. - Alle Elemente sind vom Datentyp double. - Die Indizes liegen im Bereich von 0 bis 9. const int MAXINDEX = 9; double werte[maxindex+1]; Seite 6 von 21
Eindimensionale Felder - Der Zugriff auf die einzelnen Feldelemente erfolgt unter Verwendung des Indexoperators []. - Der Index muss stets innerhalb des definierten Wertebereiches liegen. - Wird der Wertebereich verlassen, können schwerwiegende Fehler auftreten. - Die Zuweisung eines Feldes an ein anderes ist nicht möglich. zahlen[0], zahlen[1],, zahlen[19] werte[0], werte[1],, werte[19] Seite 7 von 21
Eindimensionale Felder - In folgendem Beispiel wird ein eindimensionales Feld mit 10 Elementen definiert. - Die einzelnen Elemente werden mit den Werten 0, 1,, 9 beschrieben. const int ANZAHL = 10; double feld[anzahl]; for (int i=0; i < ANZAHL; i++) feld[i] = i; Seite 8 von 21
Initialisierung von eindimensionalen Feldern - Felder können bei deren Definition initialisiert (also mit einem Startwert belegt) werden. - Hierzu wird ein Wert für jedes einzelne Feldelement angegeben. double feld[5] = {0, 2, 4, 6, 8}; Seite 9 von 21
Initialisierung von eindimensionalen Feldern - Wird die Initialisierung am Anfang nicht durchgeführt, kann auf die einzelnen Feldelemente erst zugegriffen werden, sobald diese mit Werten gefüllt wurden. - Ein double feld[5]; cout << feld[0]; führt zum Absturz des Programms, da in dem feld[0] noch kein Wert gespeichert wurde. Seite 10 von 21
Initialisierung von eindimensionalen Feldern - Es ist immer ratsam, ein Feld zu initialisieren. - Eine Teilinitialisierung ist möglich. Die restlichen, nicht angegebenen Felder, werden mit 0 initialisiert: double feld[5] = {0, 2, 4}; - Leere geschweifte Klammern bewirken eine Initialisierung aller Feldelemente mit 0: double feld[5] = {}; Seite 11 von 21
Initialisierung von eindimensionalen Feldern - Ein double feld[5] = {}; cout << feld[0]; funktioniert demnach und liefert als Ausgabe: 0.0 Seite 12 von 21
Kopieren von eindimensionalen Feldern - Die Zuweisung eines Feldes an ein anderes ist nicht möglich. double felda[5] = {}; double feldb[5] = {1, 2, 3, 4, 5}; felda = feldb // Fehler!!! Seite 13 von 21
Kopieren von eindimensionalen Feldern - Man muss die einzelnen Elemente nacheinander kopieren. double felda[5] = {}; double feldb[5] = {1, 2, 3, 4, 5}; for (int i=0; i<5; i++) felda[i] = feldb[i]; Seite 14 von 21
Operator sizeof - Der Operator sizeof ermittelt die Größe des übergebenen Datentyps oder des übergebenen Objektes in Bytes. - sizeof(feld) liefert 40. Das Feld im vorherigen Beispiel hat 5 Elemente mit jeweils 8 Bytes. - sizeof(int) liefert 4. Seite 15 von 21
Eindimensionales Feld - Beispiel - In folgendem Beispiel wird der Benutzer zur Eingabe von maximal 10 Zahlen aufgefordert. - Die Eingabe wird mit der Eingabe eines Buchstabens beendet. - Danach werden die Zahlen sortiert und ausgegeben. - Siehe Beispiel 10 Programm zu eindimensionalen Feldern (auf der Webseite zu finden). Seite 16 von 21
Mehrdimensionale Felder - Felder können mit bis zu 256 Dimensionen definiert werden. - Die am häufigsten verwendeten mehrdimensionalen Felder sind zweidimensionale Felder. - Für jede Dimension muss die Anzahl der Elemente angegeben werden. int matrix[3][3]; Seite 17 von 21
Initialisierung von mehrdimensionalen Feldern - Es ist auch möglich, mehrdimensionale Felder zu initialisieren. int matrix[3][3] = {0, 2, 4, 1, 3, 5, 7, 8, 9}; Bedeutung: matrix = 0 1 7 2 3 8 4 5 9 Seite 18 von 21
Initialisierung von mehrdimensionalen Feldern - Durch zusätzlich gesetzte Klammern kann die Zuordnungsreihenfolge verdeutlicht oder geändert werden. int matrix[3][3] = {{0, 2, 4}, {5}, {7, 8, 9}}; Bedeutung: matrix = 0 5 7 2 0 8 4 0 9 Seite 19 von 21
Kopieren von mehrdimensionalen Feldern - Das Kopieren von mehrdimensionalen Feldern funktioniert analog zu der Methode bei eindimensionalen Feldern. double matrixa[3][3] = {}; double matrixb[3][3] = {1, 2, 3, 4}; for (int i=0; i<3; i++) for (int j=0; j<3; j++) matrixa[i][j] = matrixb[i][j]; Seite 20 von 21
Mehrdimensionale Felder - Beispiel - In folgendem Beispiel werden eine 3x3-Matrix und ein Vektor mit 3 Elementen definiert. - Es wird der Vektor in die zweite Zeile der Matrix kopiert und die Matrix dann auf den Bildschirm ausgegeben. - Siehe Beispiel 11 Programm zu mehrdimensionalen Feldern (auf der Webseite zu finden). Seite 21 von 21
Kapitel 11 Zeichenverarbeitung Seite 1 von 11
Zeichenverarbeitung - Jedem Zeichen ist ein Zahlencode zugeordnet. - Dadurch wird ermöglicht, zwischen verschiedenen Systemen Texte auszutauschen. - Es werden Zahlen, Buchstaben, Steuerzeichen, Sonderzeichen, etc in eine Zahl codiert. Seite 2 von 11
Zeichenverarbeitung - Im Computer weit verbreitet ist der ASCII-Code. (American Standard Code for Information Interchange amerikanischer Standardcode für Informationsaustausch) - ASCII-Code besteht aus 7-Bit Jedes Zeichen wird durch einen 7-Bit Zahlencode repräsentiert. - Dadurch können aber nicht alle verfügbaren Zeichen abgedeckt werden, weshalb man neue Code-Tabellen entwickelte. Seite 3 von 11
Zeichenverarbeitung - Die ASCII-Code-Tabelle umfasst das "einfache" Alphabet (!, ", #, $,..., 0, 1, 2, 3,..., A, B, C, D,..., a, b, c, d,..., {,, }) und Steuerungscodes, die z.b. für die Druckersteuerung benötigt werden - insgesamt sind das 128 Zeichen. - Nicht berücksichtigt sind darin Sonderzeichen - also deutsche Umlaute, das "ß" und andere nationale Sonderzeichen. - Diese sind erst im erweiterten ASCII-Code enthalten. (128 255) Seite 4 von 11