Einf¨
uhrung in die Programmierung mit C++
Gundolf Haase
Graz, SS 2019, 29. Mai 2019
Prüfungen vorbereiten
Besser lernen dank der zahlreichen Ressourcen auf Docsity
Download-Punkte bekommen.
Heimse Punkte ein, indem du anderen Studierenden hilfst oder erwirb Punkte mit einem Premium-Abo
Leitfäden und Tipps
Prüfungen vorbereiten
Besser lernen dank der zahlreichen Ressourcen auf Docsity
Download-Punkte bekommen.
Heimse Punkte ein, indem du anderen Studierenden hilfst oder erwirb Punkte mit einem Premium-Abo
Community
Rangliste Universitäten
Finde heraus, welche laut den Docsity-Nutzern die besten Unis deines Landes sind
Kostenlose Leitfäden
Unsere Studi-Retter-Ebooks!
Lade unsere Leitfäden mit Lernmethoden, Hilfen zur Angstbewältigung und von Docsity-Tutoren erstellte Tipps zum Verfassen von Haus- und Abschlussarbeiten kostenlos herunter
Einführung in die Programmierung mit C++, Skripte von Programmieren in C++
Art: Skripte
2019/2020
Hochgeladen am 09.04.2020
unbekannter Benutzer 🇩🇪
4.5
(23)1 / 140
Diese Seite wird in der Vorschau nicht angezeigt
Lass dir nichts Wichtiges entgehen!
Zugehörige Dokumente
Unvollständige Textvorschau
Nur auf Docsity: Lade Einführung in die Programmierung mit C++ und mehr Skripte als PDF für Programmieren in C++ herunter!
Einf¨uhrung in die Programmierung mit C++
Gundolf Haase
Graz, SS 2019, 29. Mai 2019
- 1 Ein Schnelleinstieg
- 1.1 Was ist ein Programm und was n¨utzt es mir?
- 1.2 Das “Hello World” - Programm in C++
- 1.3 Interne Details beim Programmieren
- 1.4 Bezeichnungen in der Vorlesung
- 1.5 Integrierte Entwicklungsumgebungen
- 1.6 Erste Schritte mit Variablen
- 2 Variablen und Datentypen
- 2.1 Variablen
- 2.1.1 Einfache Datentypen
- 2.1.2 Bezeichner von Variablen
- 2.1.3 G¨ultigkeit von Bezeichnern
- 2.1.4 Konstante mit Variablennamen
- 2.2 Literale Konstanten
- 2.2.1 Integerliterale
- 2.2.2 Gleitkommaliterale
- 2.2.3 Zeichenliterale (Characterliterale)
- 2.2.4 Zeichenkettenkonstanten (Stringkonstanten)
- 2.3 Einige h¨ohere Datentypen in C++
- 2.3.1 Die Klasse string
- 2.3.2 Die Klasse complex
- 2.3.3 Die Klasse vector
- 2.3.4 ∗Die Klasse valarray
- 2.1 Variablen
- 3 Operatoren
- 3.1 Zuweisungsoperator
- 3.2 Arithmetische Operatoren
- 3.2.1 Un¨are Operatoren
- 3.2.2 Bin¨are Operatoren
- 3.3 Vergleichsoperatoren
- 3.4 Logische Operatoren ii INHALTSVERZEICHNIS
- 3.5 Bitorientierte Operatoren
- 3.5.1 Un¨are bitorientierte Operatoren
- 3.5.2 Bin¨are bitorientierte Operatoren
- 3.6 Operationen mit vordefinierten Funktionen
- 3.6.1 Mathematische Funktionen
- 3.6.2 Funktionen f¨ur die Klasse string (C++-Strings)
- 3.7 Inkrement- und Dekrementoperatoren
- 3.7.1 Pr¨afixnotation
- 3.7.2 Postfixnotation
- 3.8 Zusammengesetzte Zuweisungen
- 3.9 Weitere n¨utzliche Konstanten
- 4 Kontrollstrukturen
- 4.1 Einfache Anweisung
- 4.2 Block
- 4.3 Verzweigungen
- 4.4 Der Z¨ahlzyklus
- 4.5 Abweisender Zyklus
- 4.6 Nichtabweisender Zyklus
- 4.7 Mehrwegauswahl (switch-Anweisung)
- 4.8 Unbedingte Steuerungs¨ubergabe
- 5 Strukturierte Datentypen
- 5.1 Felder
- 5.1.1 Dynamischer C++-Vektor
- 5.1.2 Statischer C++-Vektor
- 5.1.3 Beispiele zu C++-Vektoren
- 5.1.4 Mehrdimensionale Felder in C++
- 5.2 Liste
- 5.3 Strukturen als einfache Klassen
- 5.4 ∗Union
- 5.5 ∗Aufz¨ahlungstyp
- 5.6 ∗Allgemeine Typvereinbarungen
- 5.1 Felder
- 6 Referenzen und Pointer
- 6.1 Pointer (Zeiger)
- 6.1.1 Deklaration von Zeigern
- 6.1.2 Zeigeroperatoren
- 6.1.3 Zeiger und Felder - Zeigerarithmetik
- 6.2 Iteratoren INHALTSVERZEICHNIS iii
- 6.2.1 Iteratorenzugriff auf array
- 6.3 Referenzen
- 6.1 Pointer (Zeiger)
- 7 Funktionen
- 7.1 Definition und Deklaration
- 7.2 Parameter¨ubergabe
- 7.3 R¨uckgabewerte von Funktionen
- 7.4 Vektoren als Parameter
- 7.5 Deklarationen und Headerfiles, Bibliotheken
- 7.5.1 Beispiel: printvec
- 7.5.2 Beispiel: student
- 7.5.3 Eine einfache Bibliothek am Beispiel student
- 7.6 Das Hauptprogramm
- 7.7 Rekursive Funktionen
- 7.8 Ein gr¨oßeres Beispiel: Bisektion
- 8 Input und Output mit Files und Terminal
- 8.1 Kopieren von Files
- 8.2 Dateneingabe und -ausgabe via File
- 8.3 Umschalten der Ein-/Ausgabe
- 8.4 Ausgabeformatierung
- 8.5 Abgesicherte Eingabe
- 9 Erste Schritte mit Klassen
- 9.1 Unsere Klasse Komplex
- 9.2 Konstruktoren
- 9.2.1 Standardkonstruktor
- 9.2.2 Parameterkonstruktor
- 9.2.3 Kopierkonstruktor
- 9.3 Der Destruktor
- 9.4 Der Zuweisungsoperator
- 9.5 Compilergenerierte Methoden
- 9.6 Zugriffsmethoden
- 9.7 Der Additionsoperator
- 9.8 Der Ausgabeoperator
- 10 Templates
- 10.1 Template-Funktionen
- 10.1.1 Implementierung eines Funktions-Templates
- 10.1.2 Implizite und explizite Templateargumente iv INHALTSVERZEICHNIS
- 10.1.3 Spezialisierung
- 10.2 Template-Klassen
- 10.2.1 Ein Klassen-Template f¨ur Komplex
- 10.2.2 Mehrere Parameter
- 10.2.3 Umwandlung einer Klasse in eine Template-Klasse
- 10.2.4 Template-Klasse und friend-Funktionen
- 10.1 Template-Funktionen
- 11 Einf¨uhrung in die STL
- 11.1 Was ist neu?
- 11.2 Wie benutze ich max element?
- 11.2.1 Container mit Standarddatentypen
- 11.2.2 Container mit Elementen der eigenen Klasse
- 11.3 Einige Grundaufgaben und deren L¨osung mit der STL
- 11.3.1 Kopieren von Daten
- 11.3.2 Aufsteigendes Sortieren von Daten
- 11.3.3 Mehrfache Elemente entfernen
- 11.3.4 Kopieren von Elementen welche einem Kriterium nicht entsprechen
- 11.3.5 Absteigendes Sortieren von Elementen
- 11.3.6 Z¨ahlen bestimmter Elemente
- 11.3.7 Sortieren mit zus¨atzlichem Permutationsvektor
- 11.3.8 Allgemeine Bemerkungen zur STL
- 12 Klassenhierarchien
- 12.1 Ableitungen von Klassen
- 12.1.1 Design einer Klassenhierarchie
- 12.1.2 Die Basisklasse
- 12.1.3 Die abgeleiteten Klassen
- 12.2 Polymorphismus
- 12.2.1 Nutzung virtueller Methoden
- 12.2.2 Rein virtuelle Methoden
- 12.2.3 Dynamische Bindung - Polymorphismus
- 12.2.4 Nochmals zu Copy-Konstruktor und Zuweisungsoperator
- 12.3 Anwendung der STL auf polymorphe Klassen
- 12.3.1 Container mit Basisklassenpointern
- 12.3.2 Sortieren eines polymorphen Containers
- 12.3.3 Summation eines polymorphen Containers
- 12.4 Casting in der Klassenhierarchie∗
- 12.4.1 Implizites Casting
- 12.4.2 Casting von Klassenpointern und -referenzen INHALTSVERZEICHNIS v
- 12.4.3 Dynamisches C++-Casting von Pointern
- 12.4.4 Dynamisches C++-Casting von Referenzen
- 12.4.5 Unsicheres statisches C-Casting von Klassenpointern
- 12.4.6 Einige Bemerkungen zum Casting
- 12.1 Ableitungen von Klassen
- 13 Tips und Tricks
- 13.1 Pr¨aprozessorbefehle
- 13.2 Zeitmessung im Programm
- 13.3 Profiling
- 13.4 Debugging
- 13.5 Einige Compileroptionen
- 14 N¨utzliche Webseiten
vi INHALTSVERZEICHNIS
2 KAPITEL 1. EIN SCHNELLEINSTIEG
Bemerkungen:
- Software = ausf¨uhrbares Programm + Programmcode + Ideen
- Der Lernprozeß beim Programmieren erfolgt typischerweise von unten nach oben in der vorangegangenen ¨Ubersicht.
- Als Mathematiker sind vorrangig Ihre mathematischen Kenntnisse und Ideen gefragt, jedoch ist deren eigenst¨andige Umsetzung ein großer Vorteil bei vielen Arbeitspl¨atzen.
- Mit fundierten Kenntnissen in einer Programmiersprache f¨allt es recht leicht weitere Pro- grammiersprachen zu erlernen.
Warnung : Das Programm auf dem Computer wird genau das ausf¨uhren, was im Pro- grammcode beschrieben ist!
Typischer Anf¨angerkommentar: Aber das habe ich doch ganz anders gemeint.
Merke : Computer sind strohdumm! Erst die (korrekte und zuverl¨assige) Software nutzt die M¨oglichkeiten der Hardware.
Warum denn C++, es gibt doch die viel bessere Programmiersprache XYZ! Der Streit uber die beste, oder die bessere Programmiersprache ist so alt wie es Programmiersprachen gibt.¨ Folgende Gr¨unde sprechen gegenw¨artig f¨ur C++:
- C++ erlaubt sowohl strukturierte, als auch objektorientierte Programmierung.
- Strukturierte Programmierung ist die Basis jeder Programmierung im wissenschaftlich- technischen Bereich.
- Sie k¨onnen in C++ reine C-Programme schreiben wie auch rein objektorientiert program- mieren, d.h., es ist eine sehr gute Trainingsplattform.
- C++ erlaubt ein h¨oheres Abstraktionsniveau beim Programmieren, d.h., ich muß mich nicht um jedes (fehleranf¨allige) informatische Detail k¨ummern. Andererseits kann ich genau dies tun, falls n¨otig.
- C++ ist eine Compilersprache, keine Interpretersprache, und damit k¨onnen die resultierenden Programme schnell sein.
- Die Gnu^1 -Compiler f¨ur C++ sind f¨ur alle g¨angigen (und mehr) Betriebssysteme, insbeson- dere Linux, Windows, Mac-OS, kostenlos verf¨ugbar. Desgleichen gibt es gute, kostenlose Programmierentwicklungsumgebungen (IDE) wie CodeBlocks^2 auf diesen. Die clang^3 -Compiler sind ebenfalls sehr zu empfehlen.
- Seit ca. 20 Jahren ist C++ meist unter den Top-5 im Programmiersprachenranking vertreten, siehe verschiedene Rankings wie TIOBE Index^4 , PYPL^5 oder LangPop^6. Die Programmier- techniken der anderen Spitzensprachen lassen sich mit C++ ebenfalls realisieren.
- C++ mit seinen Bibliotheken ist sehr gut dokumentiert, siehe cplusplus.com^7 , cpprefe- rence.com^8 und nat¨urlich stackoverflow^9 f¨ur schwierigen F¨alle.
- C++ wird weiterentwickelt, der neue C++11 und C++14^10 Standard ist in den Compilern umgesetzt. C++17 wird bereits gr¨oßtenteils unterst¨utzt und C++20 ist in Arbeit. Wir werden die M¨oglichkeiten des Standards C++11 an passender Stelle benutzen. (^1) http://gcc.gnu.org/ (^2) http://www.codeblocks.org/ (^3) https://clang.llvm.org/ (^4) http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html (^5) http://pypl.github.io/PYPL.html (^6) http://langpop.com/ (^7) http://www.cplusplus.com (^8) http://en.cppreference.com/w/ (^9) https://stackoverflow.com/ (^10) http://en.wikipedia.org/wiki/C++
1.2. DAS “HELLO WORLD” - PROGRAMM IN C++ 3
1.2 Das “Hello World” - Programm in C++
Wir beginnen mit dem einfachen “Hello World”-Programm, welches nur den String “Hello World” in einem Terminalfenster ausgeben wird. Damit l¨aßt sich schon ¨uberpr¨ufen, ob der Compiler und die IDE korrekt arbeiten (und Sie diese bedienen k¨onnen).
Listing 1.1: Quelltext von Hello World 1 #include // d e k l a r i e r t cout , e n d l using namespace s t d ; // e r l a u b t Nutzung d e s Namensraumes s t d 3 // n u t z e c o u t s t a t t s t d : : c o u t i n t main ( ) // Beginn Hauptprogramm 5 { // Beginn Scope s t d : : c o u t << ” H e l l o World ” << s t d : : e n d l ; 7 return 0 ; // Beende das Programm } // Ende Scope , Ende Hauptprogramm HelloWorld.cpp Der simple Code im Listing 1.1 enth¨alt schon einige grundlegende Notwendigkeiten eines C++- Programmes:
- Kommentare bis zum Zeilenende werden mit // eingeleitet. Der C-Kommentar /* */ kann auch in C++ verwendet werden.
- Jedes Programm ben¨otigt eine Funktion main(), genannt Hauptprogramm.
- int main() deklariert (ank¨undigen) das Hauptprogramm in Zeile 4.
- Die geschweiften Klammern { } in Zeilen 5 und 8 begrenzen den Funktionsk¨orper der Funktion main.
- In Zeile 7 wird der Ausdruck return 0 durch den Strichpunkt ; zu einer Anwei- sung im Programm. Diese spezielle Anweisung beendet das Hauptprogramm mit dem R¨uckgabewert 0.
- Die Ausgabe in Zeile 6 benutzt die I/O-Bibliotheken von C++.
- cout ist ein Bezeichner f¨ur die Ausgabe im Terminal.
- << leitet den nachfolgenden String auf den Ausgabestrom (cout) um. Dies kann wie- derholt in einer Anweisung geschehen.
- endl ist der Bezeichner f¨ur eine neue Zeile im Ausgabestrom.
- Die Preprocessor-Anweisung (beginnt mit #) in Zeile 1 inkludiert das, vom Compiler mitgelieferte, Headerfile iostream in den Quelltext. Erst dadurch k¨onnen Bezeichner wie cout und endl der I/O-Bibliothek benutzt werden.
- Ohne Zeile 2 m¨ussen der Ausgabestrom etc. ¨uber die explizite Angabe des Namensrau- mes std angegeben werden, also als std::cout. Mit Zeile 2 wird automatisch der Namensraum std ber¨ucksichtigt wodurch auch cout identifiziert wird.
Quelltext eingeben und compilieren, Programm ausf¨uhren:
- Quellfile editieren. LINUX> geany HelloWorld.cpp
- Quellfile compilieren. LINUX> g++ HelloWorld.cpp
- Programm ausf¨uhren. LINUX> a.out oder LINUX> ./a.out oder WIN98> ./a.exe
Tip zum Programmieren: Es gibt (fast) immer mehr als eine M¨oglichkeit, eine Idee im Computerprogramm zu realisieren. =⇒ Finden Sie Ihren eigenen Programmierstil und verbessern Sie ihn laufend.
1.5. INTEGRIERTE ENTWICKLUNGSUMGEBUNGEN 5
1.5 Integrierte Entwicklungsumgebungen
Obwohl nicht unbedingt daf¨ur n¨otig, werden in der Programmierung h¨aufig IDEs (Integrated Deve- lopment Environments) benutzt, welche Editor, Compiler, Linker und Debugger - oft auch weitere Tools enthalten. In der LV benutzen wir freie Compiler^11 und -entwicklungstools^12 , insbesondere die Compiler basieren auf dem GNU-Projekt und funktionieren unabh¨angig von Betriebssystem und Prozessortyp. Damit ist der von Ihnen geschriebene Code portabel und l¨auft auch auf einem Supercomputer (allerdings nutzt er diesen nicht wirklich aus, dazu sind weitere LVs n¨otig). Grund- lage des Kurses sind die g++-Compiler ab Version 4.7.1, da diese auch den neuen C++11-Standard unterst¨utzen. Gegebenenfalls muß der Code mit der zus¨atzlichen Option -std=c++11 ¨ubersetzt werden.
Wir werden unter Windows die IDE Code::Blocks^13 Version 16.01 [Stand: Feb. 2016] benut- zen welche auf den GNU-Compileren und -Werkzeugen basiert. Dies erlaubt die Programmierung unter Windows ohne die Portabilit¨at zu verlieren, da diese IDE auch unter LINUX verf¨ugbar ist. Sie k¨onnen diese Software auch einfach privat installieren, siehe Download^14 (nehmen Sie codeblocks-16.01mingw-setup.exe) und das Manual^15. Installieren Sie in jedem Fall vorher das Softwaredokumentationstool doxygen^16 (und cppcheck^17 ), da es nur dann automatisch in die IDE eingebunden wird.
Da die Entwicklungsumgebung alles vereinfachen soll, ist vor dem ersten Hello-World-Programm etwas mehr Arbeit zu investieren.
- Code::Blocks aufrufen: auf dem Desktop das Icon Code::Blocks anklicken.
- In Code::Blocks ein neues Projekt anlegen: File −→ New −→ Project
(a) Im sich ¨offnenden Fenster das Icon Console Application anklicken und dann auf Go klicken. (b) Bei der Auswahl der Programmiersprache C++ anklicken und dann Next. (c) Den Projektitel angeben - hier bitte das Namensschema bsp nr mit nr als Nummer der abzugebenden ¨Ubungsaufgabe einhalten. Den Folder (das Verzeichnis) ausw¨ahlen in welchem das Projekt gespeichert werden soll. Darin wird dann automatisch ein Unterverzeichnis mit dem Projektnamen angelegt. Next klicken. (d) Die Debug und die Release configuration aktivieren. Auf Finish klicken. (e) Im Workspace erscheint das neue Projekt bsp 1 welches in seinen Sources das File main.cpp enth¨alt. Auf dieses File klicken. (f) Im Editor sehen Sie nun folgenden Programmtext: #include
(^11) http://gcc.gnu.org/ (^12) http://www.gnu.org/ (^13) http://www.codeblocks.org/ (^14) http://www.codeblocks.org/downloads/26#windows (^15) http://www.codeblocks.org/user-manual (^16) http://www.doxygen.org (^17) http://cppcheck.sourceforge.net/
6 KAPITEL 1. EIN SCHNELLEINSTIEG
1.6 Erste Schritte mit Variablen
Wir beginnen mit dem einfachen “Hello World”-Programm, welches nur den String “Hello World” in einem Terminalfenster ausgibt. Damit l¨aßt sich schon ¨uberpr¨ufen, ob der Compiler und die IDE korrekt arbeiten (und Sie dies bedienen k¨onnen). Anschließend arbeiten wir mit ein paar einfachen Variablen.
Listing 1.2: Erweitertes “Hello World” #include // d e k l a r i e r t cout , e n d l 2 #include // d e k l a r i e r t K l a s s e s t r i n g using namespace s t d ; // e r l a u b t Nutzung d e s Namensraumes s t d 4 // n u t z e s t r i n g s t a t t s t d : : s t r i n g i n t main ( ) // Beginn Hauptprogramm 6 { // Beginn Scope c o u t << ” H e l l o World ” << e n d l ; 8 i n t i ; // D e k l a r a t i o n Ganzzahl−V a r i a b l e i c o u t << ” i = ” ; 10 c i n >> i ; // E i n l e s e n e i n e s Wertes f u e r i // Ausgeben d e s Wertes von i 12 c o u t << e n d l << ” i i s t g l e i c h ” << i << ” e i n e g a n z e Z a h l ” << e n d l ; // 14 f l o a t a , b ; // D e k l a r a t i o n Gleikomma−V a r i a b l e n c o u t << ” a b : ” ; 16 c i n >> a >> b ; c o u t << ” : : ” << a << ” ” << b << e n d l ; // ‘ e n d l ’ − new l i n e 18 // f l o a t c = a+b ; // D e k l a r a t i o n und D e f i n i t i o n von c 20 const s t r i n g s s ( ” c : : ” ) ; // D e k l a r a t i o n und D e f i n i t i o n von s s c o u t << s s << c << e n d l ; 22 return 0 ; // Beende das Programm } // Ende Scope , Ende Hauptprogramm HelloWorld_2.cpp
Obiger Code enth¨alt bekannte Teile aus dem Listing 1.1, wir werden kurz die neuen Zeilen erl¨autern:
[2] Die Deklarationen f¨ur den Datentyp (die Klasse) std::string werden inkludiert. In Zeile 3 wird der Namensraum f¨ur std freigegeben.
[8] Ein ganzzahlige Variable^18 i wird deklariert und darf damit in den nachfolgenden Zeilen des G¨ultigkeitsbereichs zwischen { und } verwendet werden, also bis zur Zeile 22. Die Variable i kann ganzzahlige Werte aus [− 2 −^31 , 2 −^31 − 1] annehmen.
[10] Die Variable i wird ¨uber den Terminal (Tastatureingabe) eingelesen. cin und >> sind Eingabestrom und -operator analog zur Ausgabe mit cout und <<.
[12] Die Variable i wird gemeinsam mit einem beschreibenden String (Zeichenkette) ausgegeben.
[14] Deklaration der Gleikommazahlen einfacher Genauigkeit (engl.: single precision^19 ) a und b.
[16] Einlesen von Werten f¨ur a und b. Ausgabe der Variablenwerte in Zeile 17.
[19] Deklaration der Gleikommavariablen c und gleichzeitige Definition (Zuweisen eines Wertes) aus den Variablen a und b. Hierbei ist = der Zuweisungsoperator und + der Additions- operator f¨ur Gleitkommazahlen.
[20] Deklaration und gleichzeitige Definition eines konstanten (const) Strings ss. Das Schl¨usselwort legt fest, daß der ss zugewiesene Wert nicht mehr ver¨andert werden kann.
[21] Gemeinsame Ausgabe des konstanten Strings und der Gleikommavariablen.
- Mit { } eingeschlossene Bereiche eines Quelltextes definieren die Grenzen eines G¨ultigkeitsbereiches (scope) von darin definierten Variablen.
Damit haben wir eine Grundlage, um uns in die Programmierung mit C++ schrittweise einzuar- beiten.
(^18) http://de.wikipedia.org/wiki/Integer_(Datentyp)#Maximaler_Wertebereich_von_Integer (^19) http://de.wikipedia.org/wiki/IEEE_754#Zahlenformate_und_andere_Festlegungen_des_ IEEE-754-Standards
8 KAPITEL 2. VARIABLEN UND DATENTYPEN
Typ Speicherbedarf Inhalt m¨ogliche Werte in Byte char 1 ASCII-Zeichen ’H’, ’e’, ’\n’ bool 1 Booleanvariable false, true [erst ab C90] signed char 1 [− 128 , 127] ; -117, 67 unsigned char 1 [0, 255] ; 139, 67 short [int] 2 [− 215 , 215 − 1] ; - unsigned short [int] 2 [0, 216 − 1] ; 40000 int 4 Ganze Zahlen [− 231 , 231 − 1] unsigned [int] 4 (integer) [0, 232 − 1] long [int] 4 wie int unsigned long [int] 4 wie unsigned int long long [int] 8 [− 263 , 263 − 1] unsigned long long [int] 8 [0, 264 − 1] size t implementierungsabh¨angig unsigned long long int float 4 Gleitkommazahlen 1.1, -1.56e- double 8 (floating point numbers) 1.1, -1.56e-132, 5.68e+
Tabelle 2.1: Speicherbedarf grundlegender Datentypen [Stand 03/2019]
- Wir werden meist den Grundtyp int f¨ur den entsprechenden Teilbereich der ganze Zahlen und unsigned int f¨ur nat¨urliche Zahlen verwenden. Die Kennzeichnung unsigned sowie das ungebr¨auchliche signed kann auch in Verbindung mit anderen Integertypen verwendet werden.
- Floating point numbers sind im Standard IEEE 754^3 definiert. Die Anzahl der Mantissenbits (float: 23; double: 52) bestimmt deren relative Genauigkeit, d.h., das Maschinen-ε, welches die kleinste Zahl des Datentyps darstellt f¨ur die 1 + ε > 1 noch gilt (float: 2−(23+1); double: 2 −(52+1)). Siehe dazu auch das hidden bit^4.
Listing 2.1: Abfrage der Speichergr¨oße von Datentypen 1 #include using namespace s t d ; 3 i n t main ( ) { 5 i n t i i ; c o u t << ” S i z e o f i n t : ” << s i z e o f ( i i ) << e n d l ; 7 c o u t << ” S i z e o f u n s i g n e d i n t : ” << s i z e o f ( unsigned i n t ) << e n d l ; return 0 ; 9 } DataTypes.cpp
2.1.2 Bezeichner von Variablen
Die Variablenbezeichner m¨ussen gewissen Regeln folgen (wiki^5 ):
- Das erste Zeichen eines Bezeichners einer Variablen muss ein Buchstabe oder Unterstrich sein.
- Die folgenden Zeichen d¨urfen nur die Buchstaben A–Z und a–z, Ziffern und der Unterstrich sein.
- Ein Bezeichner darf kein Schl¨usselwort der Sprache – zum Beispiel if, void und auto – sein.
- C/C++ unterscheidet zwischen Groß- und Kleinschreibung, d.h., ToteHosen und toteHosen Ex210.cpp sind unterschiedliche Bezeichner!
(^3) https://de.wikipedia.org/wiki/IEEE_ (^4) https://de.wikipedia.org/wiki/Gleitkommazahl#Hidden_bit (^5) http://de.wikipedia.org/wiki/C_(Programmiersprache)#Deklarationen
2.2. LITERALE KONSTANTEN 9
G¨ultig Ung¨ultig Grund i j ijl i3 3i 3 ist kein Buchstabe 3a 3*a * ist Operatorzeichen Drei mal a b-a - ist Operatorzeichen auto1 auto auto ist Schl¨usselwort
Tabelle 2.2: Einge erlaubte und nicht erlaubte Variablenbezeichner
2.1.3 G¨ultigkeit von Bezeichnern
Die Bezeichner von Variablen, Konstanten etc. sind im Regelfall lokal, d.h., ein Bezeichner ist nur innerhalb seines, von { } begrenzten Blockes von Codezeilen g¨ultig, in welchem dieser Bezeichner deklariert wurde. Daher nennt man diesen Block den G¨ultigkeitsbereich (scope) dieser Variablen. Siehe dazu Listing 1.1 und §4.2.
2.1.4 Konstante mit Variablennamen
Wird eine Variablenvereinbarung zus¨atzlich mit dem Schl¨usselwort const gekennzeichnet, so kann diese Variable nur im Vereinbarungsteil initialisiert werden und danach nie wieder, d.h., sie wirkt als eine Konstante.
Listing 2.2: Definition und Deklaration von Konstanten und Variablen #include 2 using namespace s t d ; i n t main ( ) 4 { const i n t N = 5 ; // F i r s t and o n l y i n i t i a l i z a t i o n o f c o n s t a n t N 6 i n t i , j = 5 ; // F i r s t i n i t i a l i z a t i o n o f v a r i a b l e j // u n i t i a l i z e d v a r i a b l e i 8 c o u t << ” H e l l o World\n” ; i = j+ N; 10 c o u t << e n d l << i << ” ” << j << ” ” << N << e n d l ; return 0 ; 12 } Ex226.cpp Nach der Deklaration in Zeile 6 ist die Variable i noch nicht mit einem Wert belegt, d.h., sie hat einen undefinierten Status. In Zeile 7 w¨urde der Wert von i zuf¨allig sein, je nachdem was gerade in den reservierten 4 Byte als Bitmuster im Computerspeicher steht. Damit w¨are das Ergebnis einer Berechung mit i nicht vorhersagbar (nicht deterministisch) und damit wertlos. Also sollte i gleich bei der Deklaration auch definiert (initialisiert) werden. In C++ kann man ausnutzen, daß Deklarationsteil und Implementierungsteil gemischt werden k¨onnen. Dies wird im Listing 2.3 ausgenutzt, sodaß die Variable i erst in Zeile 4 deklariert wird, wo dieser auch gleich ein sinnvoller Wert zugewiesen werden kann.
Listing 2.3: Variablen erst bei Gebrauch deklarieren const i n t N = 5 ; // F i r s t and o n l y i n i t i a l i z a t i o n o f c o n s t a n t N 2 i n t j = 5 ; // F i r s t i n i t i a l i z a t i o n o f v a r i a b l e j c o u t << ” H e l l o World\n” ; 4 i n t i = j+ N; // B e t t e r : i n i t i a l i z e v a r i a b l e a t d e c l a r a t i o n Ex226_b.cpp
2.2 Literale Konstanten
Die meisten Programme, auch HelloWorld.cpp, verwenden im Programmverlauf unver¨anderliche Werte, sogenannte Literale und Konstanten. Literale Konstanten sind Werte ohne Variablenbe- zug welche in Ausdr¨ucken explizit angegeben werden und zus¨atzliche Typinformationen enthalten k¨onnen.
2.3. EINIGE H ¨OHERE DATENTYPEN IN C++ 11
2.3 Einige h¨ohere Datentypen in C++
Die Standardbibliothek und die Standard Template Library (STL) stellen eine große Auswahl an komfortablen h¨oheren Datenkonstrukten (genauer: Klassen und Container ) zur Verf¨ugung, welche das Programmieren vereinfachen. Die intensive Anwendung der Container f¨ur eigene Datenstruk- turen (und Klassen) erfordert Kenntnisse in Klassenprogrammierung, Vererbung und Templates, welche wir erst sp¨ater behandeln werden. Um aber schon mit diesen h¨oheren Datentypen arbeiten zu k¨onnen, erfolgt hier ein kurze Einf¨uhrung in string, complex, vector und valarray. Vertiefend und weiterf¨uhrend seien dazu u.a. [KPP02, KS02, SB95] empfohlen.
2.3.1 Die Klasse string
Diese Standardklasse string [KPP02, § 18] erlaubt eine komfortable Zeichenkettenverarbeitung
Listing 2.5: Erste Schritte mit^ string 1 #include #include 3 using namespace s t d ; i n t main ( ) 5 { s t r i n g aa { ”Das i s t d e r e r s t e S t r i n g ” } ; 7 s t r i n g bb { } ; i f ( bb. empty ( ) ) // Test a u f l e e r e n S t r i n g 9 { c o u t << ” S t r i n g bb i s t noch l e e r ” <<e n d l ; 11 } bb = ” z w e i t e r S t r i n g ” ; 13 // c i n >> bb ; // d i r e k t e Eingabe e i n e s S t r i n g s s t r i n g c c=aa + ” und ” + bb ; // S t r i n g s aneinanderhaengen 15 c o u t << c c << e n d l ; // Laenge d e s S t r i n g s ausgeben 17 c o u t << ” i s t ” << c c. s i z e ( ) << ” Z e i c h e n l a n g. ” << e n d l ; s t r i n g dd ( c c ) ; // S t r i n g dd h a t g l e i c h e Laenge wie aa 19 // und g l e i c h e Daten f o r ( unsigned i n t i =0; i <dd. s i z e ( ) ; ++i ) 21 { c o u t << dd [ i ] << ” ” ; // Ausgabe i −t e s Zeichen von dd 23 } return 0 ; 25 } demoString.cpp Die Konvertierung von Zahlen in Strings und umgekehrt wird hier^6 erl¨autert.
2.3.2 Die Klasse complex
Die Standardklasse complex
Listing 2.6: Erste Schritte mit^ complex #include 2 #include
(^6) http://www.cplusplus.com/articles/D9j2Nwbp/
12 KAPITEL 2. VARIABLEN UND DATENTYPEN
} demoComplex.cpp
2.3.3 Die Klasse vector
demoVector.cpp Die Containerklasse vector
Statischer Vektor
Nachfolgender Code demonstriert den Einsatz eines statischen Vektors, d.h., die Anzahl der Vek- torelemente is a priori bekannt. Mit resize(laenge ) kann diese Anzahl der Elemente auf einen neuen Wert ge¨andert werden (dies ist eigentlich schon dynamisch). Die neuen Elemente m¨ussen danach noch mit Werten initialisiert werden.
Listing 2.7: Erste Schritte mit^ vector^ als statischem Vektor 1 #include #include
Dynamischer Vektor
Obiger Code behandelt Vektoren konstanter L¨ange. Wenn die Anzahl der Vektorelemente a priori unbekannt ist, dann kann ein vorhandener Vektor durch Benutzung der Methode push back(value ) um ein weiteres Element mit dem Wert value verl¨angert werden.
Listing 2.8: Erste Schritte mit vector als dynamischem Vektor 1 #include #include