Tobias Wolf Seite 1 von 37

Transkript

1 Skript Seite 1 von 37

2 Was ist? - ist die Wissenschaft von der systematischen Verarbeitung von Informationen, insbesondere deren automatisierte Verarbeitung mit Hilfe von elektronischen Rechenanlagen. - Die 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

3 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

4 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

5 Softwareentwicklung - Unter Softwareentwicklung versteht man die systematische Konstruktion von Programmen zur Lösung eines in der realen Welt gestellten Problems. Seite 5 von 37

6 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

7 Von-Neumann-Rechner Seite 7 von 37

8 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

9 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

10 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

11 Speicher - Im Speicher werden: o Programme o Daten o Zwischenergebnisse o Endergebnisse abgelegt - Jede Speicherzelle hat eine Adresse. Seite 11 von 37

12 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

13 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

14 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

15 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

16 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

17 Maschinensprache Beispiel Seite 17 von 37

18 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

19 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

20 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

21 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

22 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 = ; b = ; c = a + b; Seite 22 von 37

23 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

24 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

25 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

26 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

27 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

28 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

29 Ü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

30 Assembler - Assembler setzen Befehle eins zu eins aus der maschinenorientierten Sprache in die Maschinensprache um. Seite 30 von 37

31 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

32 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

33 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

34 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

35 C++ Historie Martin Richards entwickelte BCPL, assemblernahe Sprache Simula 67, Programmiersprache für mathematisch technische Probleme und Simulation, erste objektorientierte Konzepte Ken Thompson entwickelte B, eine assemblernahe Sprache; Unix Betriebssystem für PDP Dennis Ritchie (Bell Labs) entwirft C; rechnerunabhängige Sprache zur Portierung von Unix auf PDP 11 Seite 35 von 37

36 C++ Historie Kernighan und Ritchie geben das erste Referenzbuch zu C heraus Start der Arbeiten an C mit Klassen erster Entwurf von C++ durch Bjarne Stroustrup; Bell- Labs in den USA Bjarne Stroustrup veröffentlicht das Buch: The C++ Programming Language Seite 36 von 37

37 C++ Historie Veröffentlichung des ersten reinen C++ Compilers für PCs und Workstations American National Standards Institute (kurz: ANSI) veröffentlicht den ersten C Standard erste C++ Version von Borland (heute: Inprise) erste C++ Version von Microsoft Veröffentlichung des ANSI C++ Standards ISO/IEC Seite 37 von 37

38 Kapitel 2 Einführung in C++ Seite 1 von 29

39 C++ Zeichensatz - Buchstaben: a bis z und A bis Z. - Ziffern: 0 bis 9 - Sonderzeichen: ; :,. # + - * / % _ \! < > & ^ ~ ( ) { } [ ]? Seite 2 von 29

40 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

41 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

42 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

43 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

44 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 Seite 7 von 29

45 Operatoren - Operatoren dienen der Verknüpfung von Operanden. - Es sind für jeden Datentyp Operatoren vordefiniert. - Bsp: Addition + Division / Oder Seite 8 von 29

46 Interpunktionszeichen - Ein Beispiel für ein Interpunktionszeichen ist das Semikolon am Ende jeder Anweisung. a = 1; cin >> radius; Seite 9 von 29

47 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

48 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

49 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

50 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

51 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

52 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

53 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

54 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

55 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 = ; 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

56 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

57 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

58 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

59 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

60 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

61 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

62 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

63 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

64 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

65 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

66 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

67 Kapitel 3 Datentypen und Variablen Seite 1 von 18

68 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

69 Datentypen - Einführung - In dieser Tabelle sind die arithmetischen Datentypen aufgelistet: Datentyp Länge Wertebereich von bis char 1 Byte int 4 Byte float 4 Byte ± ± double 8 Byte ± ± Seite 3 von 18

70 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 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

71 Ganzzahlige Konstanten Beispiel: 4 wird im Computer so gespeichert: 1. Vorzeichen ignorieren und ins Binärsystem umrechnen 4 => Seite 5 von 18

72 Ganzzahlige Konstanten Beispiel: -4 wird im Computer so gespeichert: 1. Vorzeichen ignorieren und ins Binärsystem umrechnen 4 => Invertieren, da negativ Eine 1 addieren, da negativ => Seite 6 von 18

73 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

74 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 oktal hexadezimal 0x 0xC2-0x3D Seite 8 von 18

75 Beispiel #include <iostream> using namespace std; void main () { cout << 10; cout << 012; cout << 0xa; } Seite 9 von 18

76 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

77 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

78 Zahlensysteme - Umwandlung einer Dualzahl in eine Dezimalzahl: (010111) 2 = = (23) 10 - Umwandlung einer Oktalzahl in eine Dezimalzahl: (167) 8 = ( ) = (119) 10 - Umwandlung einer Hexadezimalzahl in eine Dezimalzahl: (C2) 16 = ( ) = (194) 10 Seite 12 von 18

79 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

80 Gleitkomma Konstanten - Beispiele für die Ein- und Ausgabe von Gleitkomma Konstanten (Gleitkommazahlen) E E+15 Seite 14 von 18

81 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

82 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

83 Initialisierung von Variablen - Man kann Variablen auch definierte Anfangswerte zuordnen. - Eine Variable sollte vor ihrer ersten Verwendung initialisiert werden. int anzahl = 1000; double PI = ; int a = 2, b = 3; Seite 17 von 18

84 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 = ; Seite 18 von 18

85 1 Kapitel 4 Ein- & Ausgabe Seite 1 von 16

86 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

87 1 Ausgabe - cout - Beispiele: cout << "Texteingabe"; cout << x; cout << a << b; cout << c << d << endl; cout << "y = " << y << endl; Seite 3 von 16

88 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

89 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 << " "; cout << setw(15) << 1.602E e-019 Seite 5 von 16

90 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; Seite 6 von 16

91 1 Ausgabe-Manipulatoren - Zur Verwendung der Manipulatoren muss die Datei iomanip eingebunden werden: #include <iomanip> Seite 7 von 16

92 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

93 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

94 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: Seite 10 von 16

95 1 Eingabe - cin - Eingabefehler kann man erkennen, indem man sie durch fail abfängt: if (cin.fail()) cout << "Eingabefehler!" << endl; Seite 11 von 16

96 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

97 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

98 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

99 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

100 1 Beispiel #include <iostream> #include <cmath> Zahl Wurzel #include <iomanip> using namespace std; void main () { 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

101 Kapitel 5 Arithmetische Operatoren Seite 1 von 16

102 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

103 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

104 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

105 Merkwürdige Ganzzahl-Arithmetik - Es gibt einen Unterschied zwischen dem, was unser Taschenrechner und dem, was der Computer berechnet. Operation Taschenrechner Computer 7/ / /2 + 1/2 1.0/ /2.0 1/ /2.0 Seite 5 von 16

106 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

107 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

108 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

109 Arithmetische Ausdrücke - Beispiele Ausdruck * / / / 3 * * * 3 % Ergebnis Seite 9 von 16

110 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

111 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

112 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

113 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

114 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

115 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

116 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

117 Kapitel 6 Vergleichsoperatoren Seite 1 von 6

118 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

119 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

120 Vergleichsoperatoren Operator Bedeutung == gleich (2 Gleichheitszeichen!)!= ungleich < kleiner <= kleiner oder gleich > größer >= größer oder gleich Seite 4 von 6

121 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

122 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

123 Kapitel 7 Verzweigungen/Bedingungen Seite 1 von 12

124 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

125 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

126 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

127 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

128 if/else -Anweisung Seite 6 von 12

129 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

130 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

131 else/if -Anweisung Seite 9 von 12

132 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

133 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

134 switch/case -Anweisung Seite 12 von 12

135 Kapitel 8 Nassi-Shneiderman-Diagramm (Struktogramm) Seite 1 von 14

136 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

137 Einfache Anweisung - Zur Darstellung einer einzeiligen Anweisung, wie z.b. cout. Seite 3 von 14

138 Einfache Anweisung - Beispiel int zahl = 3; zahl = zahl % 2; cout << "Die Zahl lautet: " << zahl << endl; Seite 4 von 14

139 Bedingung if/else - Bei zutreffender Bedingung wird der "ja-fall", ansonsten der "nein-fall" abgearbeitet. Seite 5 von 14

140 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

141 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

142 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

143 Kopfgesteuerte Schleife - Die Bedingung wird zuerst geprüft. Ist sie wahr, wird der Anweisungsblock abgearbeitet. Seite 9 von 14

144 Kopfgesteuerte Schleife - Beispiel int zahl = 0; while (zahl < 10) { cout << zahl << endl; zahl++; } // Bedingung // Anweisungsblock // Anweisungsblock Seite 10 von 14

145 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

146 Fußgesteuerte Schleife - Beispiel int zahl = 0; do { cout << zahl << endl; zahl++; } while (zahl < 10); // Anweisungsblock // Anweisungsblock // Bedingung Seite 12 von 14

147 Endlos-Schleife - Die Bedingung ist immer wahr. - Die Schleife kann deshalb nur durch ein break verlassen werden. Seite 13 von 14

148 Endlos-Schleife - Beispiel int zahl = 0; while (true) // Bedingung, die immer gültig ist { cout << zahl << endl; // Anweisungsblock zahl++; // Anweisungsblock } Seite 14 von 14

149 Kapitel 9 Schleifen Seite 1 von 25

150 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

151 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

152 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

153 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

154 for -Schleife Ausgabe: int i; for (i = 1; i <= 5; i+=2) { cout << i << endl; } Seite 6 von 25

155 for -Schleife Seite 7 von 25

156 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

157 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: Seite 9 von 25

158 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

159 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

160 for -Schleife - Die Zählvariable kann auch innerhalb des Initialisierungsausdrucks definiert werden. for (int i = 1; i <= 10; i++) Seite 12 von 25

161 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

162 while -Schleife int i = 0; while (i < 5) cout << ++i; Ausgabe: Seite 14 von 25

163 while -Schleife - Das zugehörige Struktogramm sieht wie folgt aus: Seite 15 von 25

164 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

165 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

166 do/while -Schleife - Das zugehörige Struktogramm sieht wie folgt aus: Seite 18 von 25

167 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: Seite 19 von 25

168 Geschachtelte Schleifen - Das zugehörige Struktogramm sieht wie folgt aus: Seite 20 von 25

169 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

170 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

171 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

172 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

173 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

174 Kapitel 10 Felder / Arrays Seite 1 von 21

175 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

176 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 a a a m a a a 1n 2n... mn - Vektoren sind eindimensionale und Matrizen zweidimensionale Felder. Seite 3 von 21

177 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

178 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

179 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

180 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

181 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

182 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

183 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

184 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

185 Initialisierung von eindimensionalen Feldern - Ein double feld[5] = {}; cout << feld[0]; funktioniert demnach und liefert als Ausgabe: 0.0 Seite 12 von 21

186 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

187 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

188 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

189 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

190 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

191 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 = Seite 18 von 21

192 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 = Seite 19 von 21

193 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

194 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

195 Kapitel 11 Zeichenverarbeitung Seite 1 von 11

196 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

197 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

198 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. ( ) Seite 4 von 11