%YXSVIR(*VMWGLEPS[WOM->MQQIVQERR 3FNIOXSVMIRXMIVXI4VSKVEQQMIVYRK F],)6(8:IVPEKJÚV&MPHYRKWQIHMIR+QF,

'3 %YXSVIR(*VMWGLEPS[WOM->MQQIVQERR %YJPEKIZSQ2SZIQFIV F],)6(8:IVPEKJÚV&MPHYRKWQIHMIR+QF, &SHIRLIMQ -RXIVRIX[[[LIVHX]SYHIEXGL [[[LIVHXFYWMRIWWHIEXGL [[[LIVHXZLWHIEX %PPI 6IGLXI ZSVFILEPXIR /IMR 8IMP HIW ;IVOIW HEVJ MR MVKIRHIMRIV*SVQ(VYGO*SXSOSTMI1MGVSJMPQSHIVIMRIQ ERHIVIR :IVJELVIR SLRI WGLVMJXPMGLI +IRILQMKYRK HIW,IVEYWKIFIVW VITVSHY^MIVX SHIV YRXIV :IV[IRHYRK IPIOXVSRMWGLIV 7]WXIQI ZIVEVFIMXIX ZIVZMIPJÂPXMKX SHIV ZIVFVIMXIX[IVHIR (MIWI 9RXIVPEKI [YVHI QMX KVS½IV 7SVKJEPX IVWXIPPX YRH KITVÚJX8VSX^HIQ OÔRRIR *ILPIV RMGLX ZSPPOSQQIR EYW KIWGLPSWWIR [IVHIR :IVPEK,IVEYWKIFIV YRH %YXSVIR OÔRRIRJÚVJILPIVLEJXI%RKEFIRYRHHIVIR*SPKIR[IHIV IMRI NYVMWXMWGLI :IVERX[SVXYRK RSGL MVKIRHIMRI,EJXYRK ÚFIVRILQIR (MI &MPHYRKWQIHMIR HIW,)6(8:IVPEKW IRXLEPXIR 0MROW F^[ :IV[IMWI EYJ -RXIVRIXWIMXIR ERHIVIV %RFMIXIV %YJ -RLEPX YRH +IWXEPXYRK HMIWIV %RKIFSXI LEX HIV,)6(8 :IVPEK OIMRIVPIM )MRJPYWW,MIVJÚV WMRH EPPIMRI HMI NI[IM PMKIR%RFMIXIVZIVERX[SVXPMGL &SVPERH 1MGVSWSJX YRH 0MRY\ # 3FNIOXSVMIRXMIVXI4VSKVEQQMIVYRK QMX' Ã Ã Ã '3Ã Ã

I NHALTSVERZEICHNIS Objektorientierte Programmierung mit C++ 1 Einführung in C++...4 4 Klassen...30 1.1 Die Entstehung von C++... 4 1.2 Standards... 5 1.3 Bezeichnung der Dateinamen... 5 1.4 Umgang mit Neuerungen... 5 4.1 Klassen, Instanzen und Objekte... 30 4.1.1 Einfache Syntax der Klassendeklaration...31 4.1.2 Instanzen einer Klasse...32 4.1.3 Zugriff auf die Members einer Klasse...32 4.2 Konstruktoren und Destruktoren... 34 4.3 Friends... 35 2 Einfache Erweiterungen von C++...6 2.1 Kommentarzeilen... 6 4.4 Statische Klassenelemente... 36 4.5 Übung... 37 2.2 Deklarationen... 6 2.3 Der Operator ::... 7 2.4 Defaultwerte... 7 2.4.1 Syntax für den Einsatz von Defaultwerten... 8 2.5 Inline-Funktionen... 9 2.6 Mischen von C- und C++- Quellen... 10 2.7 Dynamische Speicherverwaltung...10 2.7.1 New... 11 2.7.2 Delete... 12 2.7.3 Fehlerbehandlung über new-handler... 13 2.8 Typinformationen... 14 2.9 Referenzen und Referenzvariablen... 14 2.10 Referenzparameter... 16 2.11 Referenzen als Funktionsergebnisse... 18 2.12 Überladen von Funktionen... 19 2.13 Übung... 21 5 Vererbung...38 5.1 Einführung... 38 5.2 Syntax der Vererbung... 40 5.3 Art der Ableitung... 40 5.4 Strukturen und Klassen... 43 5.5 Konstruktoren und Destruktoren abgeleiteter Klassen... 44 5.6 Kompatibilität in Klassenhierarchien... 46 5.6.1 Zuweisung von Objekten abgeleiteter Klassen...46 5.6.2 Zeiger auf Basisklassen und abgeleitete Klassen...47 5.7 Klassenhierarchien... 49 5.8 Der this-zeiger... 50 5.9 Virtuelle Funktionen... 50 5.10 Virtuelle Destruktoren... 52 5.11 Übung... 55 3 Streams...22 3.1 Einführung... 22 3.2 Standardausgabestream cout... 23 3.3 Standardeingabestream cin... 26 3.4 Übung... 29 6 Mehrfachvererbung...56 6.1 Mehrfachvererbung... 56 6.2 Virtuelle Basisklassen... 58 6.3 Übung... 61

Inhaltsverzeichnis I 7 Polymorphismus...62 10 Templates...96 7.1 Einleitung...62 7.2 Rein virtuelle Funktionen...62 7.3 Abstrakte Basisklassen...63 7.4 Übung...65 10.1 Einführung...96 10.2 Funktionen-Templates...97 10.2.1 Syntax für Funktionen-Templates...97 10.3 Klassen-Templates...98 10.3.1 Syntax für Klassen-Templates...99 10.4 Übung...101 8 Datei- und String-Streams...66 8.1 Die I/O-Stream-Klassenhierarchie...66 8.2 Datei-Streams...68 8.3 String-Streams...70 8.3.1 Zerlegen von Strings: istrstream...71 8.3.2 Zusammensetzen von Strings: ostrstream...72 11 Exceptionhandling...102 11.1 Einführung...102 11.1.1 Syntaxder Fehlerbehandlung... 103 11.2 Übung...105 8.4 Übung...73 12 Objektorientierter Entwurf...106 9 Überladen von Operatoren...74 9.1 Einleitung...74 9.2 Operator-Overloading durch friend - Funktionen...75 9.3 Operator-Overloading mit Elementfunktionen...77 9.4 Allgemeines zum Operator-Overloading...79 9.5 Typumwandlungs-Operatoren...79 9.5.1 Konstruktoren als Typumwandlungs- Operatoren...81 9.5.2 Typumwandlungsoperator-Funktionen...82 9.6 Kopieren von Objekten...84 9.7 Überladen des Funktionsoperators ()...87 9.8 Überladen des Komponentenzugriffs ->...90 9.9 Überladen von new und delete...91 12.1 Einführung...106 12.2 Das Objektmodell...107 12.3 Identifizieren von Klassen...108 12.4 Verifizieren der Klassen durch Szenarios...109 12.5 Gemeinsamkeiten und Beziehungen zwischen Klassen...109 12.6 Verfeinerung durch Identifizieren der Daten...110 12.7 Graphische Darstellung von Klassen und Beziehungen...111 12.8 Design-Fehler...114 12.9 Übung...114 Stichwortverzeichnis...116 9.10 Übung...94

3 Objektorientierte Programmierung mit C++ 3 Streams,Q GLHVHP.DSLWHO HUIDKUHQ 6LH Æ ZDV HLQ 6WUHDP LVW Æ ZLH GLH (LQ XQG $XVJDEH EHU 6WUHDP GXUFKJHI KUW ZLUG Æ ZHOFKH 9RUWHLOH 6WUHDPV ELHWHQ 9RUDXVVHW]XQJHQ 9 *UXQGODJHQ YRQ & 3.1 Einführung 6WUHDPV VWHOOHQ GHQ JHVDPWHQ 8PIDQJ GHU %LEOLRWKHN stdio.h gets puts printf LQ HLQHU DQGHUHQ )RUP ]XU 9HUI JXQJ (LQ 6WUHDP LVW HLQ 'DWHQIOX YRQ HLQHU 4XHOOH ]X HLQHP =LHO (V P VVHQ QLFKW PHKU GLH 'DWHQW\SHQ GHU ]X EHUWUDJHQGHQ 'DWHQ DQJHJHEHQ ZHUGHQ ZLH ]% EHL GHU )XQNWLRQ printf GD GXUFK GLH 7\SLQIRUPDWLRQ GLH DXWRPDWLVFK LQ & ]XU 9HUI JXQJ VWHKW GLHV QLFKW PHKU HUIRUGHUOLFK LVW 'XUFK GLHVH DXWRPDWLVFKH 7\SSU IXQJ ZHUGHQ 6\VWHPDEVW U]H YHUPLHGHQ ZLH VLH ]% EHL IDOVFKHU 3DUDPHWHUDQJDEH EHL 9HUZHQGXQJ YRQ printf DXIWUHWHQ Z UGHQ char *str; // uninitialisierter Zeiger // keine Überprüfung der Datentypen und Anzahl der Parameter -> unerwartetes Verhalten printf ("Dies ist keine Integer-Zahl %d", str, str); =XU (LQ XQG $XVJDEH VWHKHQ YLHU YRUGHILQLHUWH 6WUHDPV ]XU 9HUI JXQJ FRXW FLQ FHUU FORJ 6WDQGDUGDXVJDEHVWUHDP 6WDQGDUGHLQJDEHVWUHDP 6WDQGDUGIHKOHUDXVJDEHVWUHDP JHSXIIHUWHU 6WDQGDUGIHKOHUDXVJDEHVWUHDP 'LH,PSOHPHQWLHUXQJ YRQ 6WUHDPV HUIROJW LQ YHUVFKLHGHQHQ.ODVVHQ YJO 7KHPD.ODVVHQ 'DEHL N QQHQ IRO JHQGH *UXSSLHUXQJHQ YRUJHQRPPHQ ZHUGHQ 6WDQGDUGDXVJDEH 'DWHL 6SHLFKHU $XVJDEH RVWUHDP RIVWUHDP RVWUVWUHDP (LQJDEH LVWUHDP LIVWUHDP LVWUVWUHDP (LQ XQG $XVJDEH LRVWUHDP LRIVWUHDP VWUVWUHDP +HDGHUGDWHL LRVWUHDPK IVWUHDPK VWUVWUHDPK 'LH.ODVVHQ GHU (LQ XQG $XVJDEH HLQHV 6WUHDPV 6WDQGDUGHLQDXVJDEH7DVWDWXU%LOGVFKLUP 'DWHL 6SHLFKHU ZHUGHQ MHZHLOV LPPHU LQ HLQHU.ODVVH ]XVDPPHQJHID W 6LH P VVHQ LQ,KUHP 3URJUDPP GDQQ MHZHLOV QXU GLH EHWUHIIHQGH +HDGHU'DWHL K HLQELQGHQ 'DPLW 6LH 6WUHDPV I U GLH (LQ XQG $XVJDEH DXI GHQ %LOGVFKLUP 6WDQGDUG YHUZHQGHQ N QQHQ PX GLH 'DWHL iostream.h HLQJHEXQGHQ ZHUGHQ

Streams 3 #include <iostream.h> 8P GHQ 6WUHDP0HFKDQLVPXV ]X YHUVWHKHQ LVW QRUPDOHUZHLVH GLH.HQQWQLV YRQ.ODVVHQ XQG 2EMHNWHQ QRW ZHQGLJ,P IROJHQGHQ ZLUG VLFK GDUDXI EHVFKUlQNW PLW GHQ 6WUHDPV ]X DUEHLWHQ RKQH QlKHU DXI GHQ =XVDP PHQKDQJ PLW.ODVVHQ HLQ]XJHKHQ 3.2 Standardausgabestream cout hehu GLHVHQ 6WUHDP ZLUG HLQH $XVJDEH DXI GHP 6WDQGDUGDXVJDEHJHUlW HU]HXJW ZDV LQ GHQ PHLVWHQ )loohq GHU %LOGVFKLUP LVW 'LH DXV]XJHEHQGHQ 'DWHQ ZHUGHQ GXUFK GHQ $XVJDEHRSHUDWRU << DQ GHQ $XVJDEHVWUHDP JHVFKLFNW,QQHUKDOE HLQHU $XVJDEHDQZHLVXQJ N QQHQ PHKUHUH 'DWHQ GXUFK << YHUNHWWHW ZHUGHQ cout << "Hallo " << "C++ " << "Welt!"; =XU $XVJDEH N QQHQ EHOLHELJH $XVGU FNH DQJHJHEHQ ZHUGHQ (V ZLUG ]XHUVW GDV (UJHEQLV GHV $XVGUXFNV EH UHFKQHW XQG GDQQ GDV (UJHEQLV DXVJHJHEHQ 8P GLH $XVJDEH Das Ergebnis von 7 mal 9 ist 63 ]X HU]HXJHQ YHUZHQGHQ 6LH GLH IROJHQGH $QZHLVXQJ cout << "Das Ergebnis von " << 7 << " mal " << 9 << " ist " << 7 * 9; :LH 6LH VHKHQ EUDXFKHQ 6LH NHLQH $QJDEHQ ]X GHQ EHUJHEHQHQ 'DWHQW\SHQ ]X PDFKHQ -HGHU 'DWHQW\S YHU I JW EHU HLQH YRUGHILQLHUWH $XVJDEHIRUP Formatierung der Ausgabe ) U GLH )RUPDWLHUXQJ GHU DXVJHJHEHQHQ 'DWHQ VWHKHQ VRJHQDQQWH 0DQLSXODWRUHQ ]XU 9HUI JXQJ 'LHVH ZHU GHQ JHQDX ZLH GLH 'DWHQ EHU GHQ 2SHUDWRU << DQ den Ausgabestream EHUJHEHQ 8P ]% HLQHQ =HLOHQYRUVFKXE EHL GHU $XVJDEH ]X HUKDOWHQ printf ("\n"); ZLUG GHU 0DQLSXODWRU endl HLQJHVHW]W cout << "Jetzt folgt ein Zeilenumbruch." << endl << "Dieser Text steht in einer neuen Zeile"; Notizen

3 Objektorientierte Programmierung mit C++ 2SHUDWRU GHF KH[ RFW %HVFKUHLEXQJ 'LH GHP 0DQLSXODWRU IROJHQGH 'H]LPDO]DKO ZLUG GHF GH]LPDO RFW RNWDO KH[ KH[DGH]LPDO DXVJHJHEHQ // Ausgabe einer Zahl in drei Zahlensystemen: cout << "oktal: " << oct << 255 << endl; cout << "hexadezimal: " << hex << 255 << endl; cout << "dezimal: " << dec << 255 << endl << endl; VHWZLQW [ ) U GLH QlFKVWH $XVJDEH EHU cout XQG QXU I U GLHVH ZLUG GLH GXUFK GHQ 3DUDPHWHU x DQJHJHEHQH $XVJDEHEUHLWH HLQJHVHW]W 'D GLH $XVJDEH JUXQGVlW]OLFK UHFKWVE QGLJ HUIROJW ZLUG VRPLW YRU GHU QlFKVWHQ $XVJDEH PLW ) OO]HLFKHQ DXIJHI OOW // drei Zahlen werden untereinander ausgegeben cout << setw(8) << 565 << endl; cout << setw(8) << 34113 << endl; cout << setw(8) << 8 << endl << endl; VHWILOOLQW [ 1LPPW GLH $XVJDEH ZHQLJHU =HLFKHQ HLQ DOV ]% EHU setw HLQJHVWHOOW ZXUGH NDQQ PLW setfill DQJHJHEHQ ZHUGHQ ZHOFKHV =HLFKHQ DOV ) OO]HLFKHQ YHUZHQGHW ZLUG 6WDQGDUGPl LJ ZLUG PLW /HHU]HLFKHQ DXIJHI OOW // Legt als Füllzeichen den Punkt (.) fest cout << setfill('.'); cout << setw(8) << 8 << endl; VHWSUHFLVLRQLQW [ hehu GHQ 0DQLSXODWRU setprecision ZLUG GLH *HQDXLJNHLW GHU $XVJDEH GHU 1DFK NRPPDVWHOOHQ DOOHU QDFKIROJHQGHQ )OLH NRPPD]DKOHQDXVJDEHQ IHVWJHOHJW 'LH OHW]WH 6WHOOH ZLUG JHUXQGHW // Die Genauigkeit wird auf drei Stellen eingestellt. cout << setprecision(3); VHWLRVIODJVLRVIODJ setiosflags HUP JOLFKW GDV 6HW]HQ YRQ $XVJDEHIRUPDWLHUXQJVIODJV $X HU GHQ ELVKHU JHQDQQWHQ )ODJV N QQHQ ios::right UHFKWVE QGLJ XQG ios::left OLQNV E QGLJ I U GHQ 3DUDPHWHU flag DQJHJHEHQ ZHUGHQ // Setzt die Ausrichtung auf rechts. cout << setiosflags (ios::right); UHVHWLRIODJV LRVIODJ IOXVK HQGO 6HW]W GLH DQJHJHEHQHQ )ODJV ZLHGHU ]XU FN 'HU $XVJDEHSXIIHU ZLUG JHOHHUW $OOH ELVKHU JHWlWLJWHQ $XVJDEHQ ZHUGHQ GXUFKJH I KUW GLH $XVJDEH ZLUG QRUPDOHUZHLVH JHSXIIHUW GXUFKJHI KUW 'LHVH 0 JOLFKNHLW GHQ $XVJDEHSXIIHU ]XOHHUHQ LVW ]% EHL 7HVW]ZHFNHQ EHU GHQ 'HEXJJHU GLHQOLFK endl HU]HXJW HLQHQ =HLOHQXPEUXFK (LQ =HLOHQXPEUXFK NDQQ DXFK GXUFK GLH $XVJDEH YRQ "\n" EHZLUNW ZHUGHQ %HL GHQ IROJHQGHQ EHLGHQ $QZHLVXQJHQ JLEW HV MHGRFK HL QHQ XQWHU 8PVWlQGHQ ZHVHQWOLFKHQ 8QWHUVFKLHG cout << endl; cout << "\n"; %HLGH $QZHLVXQJHQ HU]HXJHQ HLQHQ =HLOHQXPEUXFK 'D GLH $XVJDEH MHGRFK JHSXIIHUW HUIROJW LVW QLFKW JDUDQWLHUW GD GLH ELVKHU PLW cout DXVJHJHEHQHQ =HLFKHQ ]X GLH VHP =HLWSXQNW ZLUNOLFK DQJH]HLJW ZHUGHQ E]Z IROJHQGH $XVJDEHQ VRIRUW GXUFKJH I KUW ZHUGHQ 'LH $XVJDEH HUIROJW JDUDQWLHUW ZHQQ endl HLQJHVHW]W RGHU GLH $XVJD EHULFKWXQJ JHZHFKVHOW ZLUG GK ZHQQ cin YHUZHQGHW ZLUG

Streams 3 8P GLH 0DQLSXODWRUHQ setw setfill setprecision setiosflags iomanip.h QDFK iostream.h HLQJHEXQGHQ ZHUGHQ HLQ]XVHW]HQ PX GLH +HDGHU'DWHL 'DV 3URJUDPP 0$1,3 YHUZHQGHW HLQLJH GHU 0DQLSXODWRUHQ I U GLH IRUPDWLHUWH $XVJDEH HLQHV,QKDOWVYHU]HLFK QLVVHV Einführung...5 Referenz...28 Übungen...45 #include <iostream.h> #include <iomanip.h> void main() { // Inhaltsverzeichnis: cout << setfill('.'); cout << setiosflags(ios::left) << setw(30) << "Einführung"; cout << setiosflags(ios::right) << setw(5) << 5 << endl; cout << setiosflags(ios::left) << setw(30) << "Referenz"; cout << setiosflags(ios::right) << setw(5) << 28 << endl; cout << setiosflags(ios::left) << setw(30) << "Übungen"; cout << setiosflags(ios::right) << setw(5) << 45 << endl; cin.peek (); } ) U GLH %LOGVFKLUPDXVJDEH EHU cout PX GLH +HDGHU'DWHL iostream.h HLQJHEXQGHQ ZHUGHQ 'LH 0DQLSXODWRUHQ setfill setiosflags XQG setw EHQ WLJHQ GLH +HDGHU'DWHL iomanip.h,p IROJHQGHQ VROO HLQ,QKDOWVYHU]HLFKQLV DXVJHJHEHQ ZHUGHQ $OV ) OO]HLFKHQ ZLUG GHU 3XQNW IHVWJHOHJW 'LH $XVULFKWXQJ ZLUG DXI OLQNV IHVWJHOHJW 'LH $XVJDEHEUHLWH ZLUG DXI =HLFKHQ PD[ 9HU]HLFKQLV HLQWUDJ IHVWJHOHJW XQG HLQ (LQWUDJ DXVJHJHEHQ ) U GLH $XVJDEH GHU 6HLWHQ]DKOHQ ZLUG HLQH $XVJDEHEUHLWH YRQ =HLFKHQ IHVWJHOHJW XQG GLH $XVULFK WXQJ DXI UHFKWV HLQJHVWHOOW $OV ) OO]HLFKHQ GLHQW LPPHU QRFK GHU LQ IHVWJHOHJWH 3XQNW (LQLJH GHU 0DQLSXODWRUHQ EHVLW]HQ HLQH ltxlydohqwh )XQNWLRQ LQQHUKDOE GHU 6WUHDP NODVVHQ GLH GLH JOHLFKH )XQNWLRQDOLWlW EHVLW]W 'LHVH )XQNWLRQHQ ZHUGHQ GLUHNW EHU cout HLQJHVHW]W setfill setw precision fill width precision cout.fill ('x'); cout.width (10); cout << "Test"; // setzt das Füllzeichen auf x // legt die Ausgabebreite auf 10 Zeichen fest Notizen

3 Objektorientierte Programmierung mit C++ Eigene Manipulatoren 'D 0DQLSXODWRUHQ QXU )XQNWLRQHQ VLQG N QQHQ 6LH VRJDU,KUH HLJHQHQ 0DQLSXODWRUHQ HU]HXJHQ 'D]X YHUZHQ GHQ 6LH GLH HQWVSUHFKHQGH 6WUHDP.ODVVH I U GLH (LQ RGHU $XVJDEH (V ZLUG HLQ QHXHU 0DQLSXODWRU EigManip I U GLH $XVJDEH GHILQLHUW $OV 3DUDPHWHU EHNRPPW GLH )XQNWLRQ GHQ ELVKHULJHQ 6WUHDP EHU outf EHUJHEHQ 'LHVHU ZLUG ZLHGHU ]XU FNJHJHEHQ XQG GLH HLJHQHQ 2SHUDWLRQHQ ZHUGHQ DQJHKlQJW %HLP (LQOHVHQ LVW GLH 5HLKHQIROJH JHQDX XPJHNHKUW ostream& EigManip (ostream& outf) { return outf << "\t "; } cout << "Test" << EigManip << "Test"; 3.3 Standardeingabestream cin 'HU 6WDQGDUGHLQJDEHVWUHDP GLHQW ]XP (LQOHVHQ YRQ 'DWHQ YRQ GHU 6WDQGDUGHLQJDEH PHLVW GHU 7DVWDWXU 'LH 'DWHQ GLH HLQJHOHVHQ ZHUGHQ VROOHQ P VVHQ LQ 9DULDEOHQ JHVSHLFKHUW ZHUGHQ 'HU 7\S GLHVHU 9DULDEOHQ PX GHP 7\S GHU HLQ]XOHVHQGHQ 'DWHQ HQWVSUHFKHQ 'LH 'DWHQHLQJDEH YRQ GHU 7DVWDWXU LQ GLH HQWVSUHFKHQGHQ 9D ULDEOHQ HUIROJW EHU GHQ (LQJDEHRSHUDWRU >> int i; cin >> i; // eine integer-variable deklarieren // Einlesen eines Wertes in die Variable i %HLP (LQOHVHQ EHU GHQ (LQJDEHRSHUDWRU ZHUGHQ 6RQGHU]HLFKHQ ZLH /HHU]HLFKHQ XQG RETURN EHUOHVHQ 'LH IROJHQGHQ =HLFKHQ ZHUGHQ VR ODQJH LQ GHQ JHZ QVFKWHQ 7\S NRQYHUWLHUW ELV HLQ =HLFKHQ DXI WULWW GDV QLFKW NRQYHUWLHUW ZHUGHQ NDQQ int i; cin >> i; (UIROJW MHW]W HLQH (LQJDEH YRQ 25Test ZLUG GHU 9DULDEOHQ i QXU GHU :HUW ]XJHZLHVHQ XQG GDQDFK DE JHEURFKHQ GD GLH I KUHQGHQ /HHU]HLFKHQ EHUOHVHQ ZHUGHQ XQG GLH %XFKVWDEHQ QLFKW LQ HLQH =DKO NRQYHUWLHUW ZHUGHQ N QQHQ )OLH NRPPD]DKOHQ N QQHQ DXI GLH JOHLFKH :HLVH HLQJHOHVHQ ZHUGHQ MHGRFK LVW DXFK GLH $QJDEH HLQHV 'H]L PDOSXQNWV XQG HLQHV ([SRQHQWHQ HUODXEW 6ROOHQ PLWWHOV cin =HLFKHQ HLQJHOHVHQ ZHUGHQ PX OHGLJOLFK HLQH 9DULDEOH GHV 7\SV char DQJHJHEHQ ZHU GHQ +LHUEHL ZHUGHQ MHGRFK /HHU]HLFKHQ :KLWHVSDFH LJQRULHUW :HQQ 6LH DXFK GLHVH =HLFKHQ HLQOHVHQ P FK WHQ P VVHQ 6LH GLH )XQNWLRQ get YHUZHQGHQ get LVW HLQH VRJHQDQQWH (OHPHQWIXQNWLRQ YJO 7KHPD.ODV VHQ char c; cin.getc (c); // liest ein einzelnes Zeichen ein c LVW GDEHL HLQH 9DULDEOH GHV 7\SV char hehu GHQ 0DQLSXODWRU ws N QQHQ /HHU]HLFKHQ EHUOHVHQ GK LJQRULHUW ZHUGHQ char c1, c2; cin >> c1 >> ws >> c2;

Streams 3 hehu GLH )XQNWLRQ ignore NDQQ HLQH IHVWJHOHJWH $Q]DKO YRQ =HLFKHQ DXV GHP 6WDQGDUGHLQJDEHVWUHDP LJQR ULHUW ZHUGHQ 'D]X ZHUGHQ LQ.ODPPHUQ GLH ]X EHUOHVHQGHQ =HLFKHQ DQJHJHEHQ char c1, c2; cin >> c1; cin.ignore (10); cin >> c2; // ein Zeichen wird eingelesen // die nächsten 10 Zeichen werden ignoriert // das nächste Zeichen wird gelesen (V NDQQ LQ GHU )XQNWLRQ ignore DXFK HLQ ]ZHLWHU 3DUDPHWHU DQJHJHEHQ ZHUGHQ GHU GHQ %HJUHQ]HU GHOLPLWHU EH]HLFKQHW 7ULWW GLHVHV =HLFKHQ LQQHUKDOE GHU DQJHJHEHQHQ =HLFKHQDQ]DKO DXI ZLUG GDV hehuohvhq YRQ =HL FKHQ DEJHEURFKHQ 9RUHLQJHVWHOOW LVW GHU %HJUHQ]HU (2) 'LHVHV =HLFKHQ VWHKW I U GDV (QGH HLQHU 'DWHL XQG LVW LP 0RPHQW QRFK QLFKW YRQ %HGHXWXQJ hehu GLH $QZHLVXQJ cin.ignore(10, '\n'); N QQHQ PD[LPDO =HLFKHQ EHUOHVHQ ZHUGHQ HV VHL GHQQ GD GDV =HLFKHQ '\n' (Zeilenumbruch) GDULQ HQWKDOWHQ LVW 'LH )XQNWLRQ ignore LVW DXIJUXQG GHU IROJHQGHQ 3UREOHPDWLN YRQ ZLFKWLJHU %HGHXWXQJ %HWUDFKWHQ 6LH GLH IRO JHQGH $QZHLVXQJVIROJH int i; char Taste; ÃÃ Praxistip cout << "Geben Sie bitte eine Zahl ein: "; cin >> i; // i einlesen cout << "Das Quadrat von " << i << " ist " << i * i; // Ergebnis ausgeben cout << "Betätigen Sie eine beliebige Taste, um fortzusetzen!"; cin.get (Taste); // auf Eingabe warten 1DFK GHU $XVJDEH GHV (UJHEQLVVHV VROO JHZDUWHW ZHUGHQ ELV GHU %HQXW]HU HLQH EHOLHELJH 7DVWH EHWlWLJW 7H VWHQ 6LH GLHVHV 3URJUDPP 6LH ZHUGHQ IHVWVWHOOHQ GD GDV 3URJUDPP ZLGHU (UZDUWHQ QDFK GHQ $XVJDEHQ EHHQGHW ZLUG RKQH GD HLQH ZHLWHUH (LQJDEH DEJHZDUWHW ZLUG,P IROJHQGHQ VROO ]XU / VXQJ GHV 3UREOHPV GHU =XVWDQG GHV (LQJDEHSXIIHUV EHWUDFKWHW ZHUGHQ =X %HJLQQ GHV 3URJUDPPV LVW GLHVHU OHHU %HL GHU HUVWHQ (LQJDEH JLEW GHU %HQXW]HU HLQH =DKO ]% HLQ XQG VFKOLH W GLHVH (LQJDEH PLW RETURN DE 'LHVH =HLFKHQ ZHUGHQ LQ GHQ (LQJDEHSXIIHU JHVWHOOW Notizen

3 Objektorientierte Programmierung mit C++ $XFK GLH RETURN KLQWHUOl W HLQ =HLFKHQ LP (LQJDEHSXIIHU QlPOLFK GDV =HLOHQHQGH]HLFKHQ \n %HLP (LQOHVHQ GHU 9DULDEOHQ i ZHUGHQ GDQQ GLH =LIIHUQ DXV GHP (LQJDEHSXIIHU JHOHVHQ XQG GHU :HUW JHVSHL FKHUW 'DV =HLOHQHQGH]HLFKHQ EOHLEW MHGRFK LP (LQJDEHSXIIHU GD HV LP 6LQQH YRQ cin QLFKW LQ HLQHQ *DQ]]DKOZHUW XPJHZDQGHOW ZHUGHQ NDQQ 6RPLW ZLUG EHLP DEVFKOLH HQGHQ (LQOHVHQ PLWWHOV cin.get(taste) QLFKW PHKU JHZDUWHW ELV QHXH =HLFKHQ PLW GHU 7DVWDWXU HLQJHJHEHQ ZHUGHQ GD VLFK MD RKQHKLQ VFKRQ HLQ =HLFKHQ LP (LQ JDEHSXIIHU EHILQGHW QlPOLFK \n 'LHVHV ZLUG QXQ JHOHVHQ XQG LQ GHU 9DULDEOHQ Taste JHVSHLFKHUW,Q GLH VHP )DOO PX GDV XQLQWHUHVVDQWH =HLOHQHQGH]HLFKHQ YRUKHU DXV GHP (LQJDEHSXIIHU HQWIHUQW ZHUGHQ 'D]X NDQQ ]% GLH REHQ HUZlKQWH )XQNWLRQ ignore HLQJHVHW]W ZHUGHQ ]% cin.ignore(100, \n ); (V ZHUGHQ =HLFKHQ EHUOHVHQ HV VHL GHQQ GD YRUKHU GDV =HLFKHQ \n JHOHVHQ ZLUG 6RPLW ZHUGHQ DXFK ZHLWHUH HYHQWXHOO IDOVFK HLQJHJHEHQH =HLFKHQ ZLH ]% EHL HLQHU (LQJDEH YRQ 13hallo EHUOHVHQ 'LH IHVWH $QJDEH HLQHV :HUWHV ZLH LVW DOOHUGLQJV XQJ QVWLJ GD GDGXUFK QLFKW JDUDQWLHUW ZLUG GD LPPHU ELV ]XP =HLOHQHQGH]HLFKHQ JHOHVHQ ZLUG GLH (LQJDEH NDQQ DXFK OlQJHU VHLQ $XFK HLQ JU HUHU :HUW Z UGH GDV 3UREOHP QLFKW O VHQ,P IROJHQGHQ ZLUG QRFK HLQH DQGHUH 0 JOLFKNHLW YRUJHVWHOOW GLHVHV 3UREOHP ]X EHKHEHQ Zeichenketten einlesen 6ROOHQ =HLFKHQNHWWHQ 6WULQJV HLQJHOHVHQ ZHUGHQ NDQQ HEHQIDOOV cin YHUZHQGHW ZHUGHQ $OOHUGLQJV ZHUGHQ KLHU DXWRPDWLVFK I KUHQGH /HHU]HLFKHQ LJQRULHUW XQG GLH (LQJDEH EHL GHP QlFKVWHQ YRUNRPPHQGHQ /HHU]HL FKHQ DOV EHHQGHW DQJHVHKHQ 'HVKDOE YHUZHQGHW PDQ ]XP (LQOHVHQ YRQ 6WULQJV ]XPHLVW GLH )XQNWLRQ get PLW GHU DX HU HLQ]HOQHQ =HLFKHQ DXFK =HLFKHQNHWWHQ HLQJHOHVHQ ZHUGHQ N QQHQ $X HU GHU 6WULQJYDULDEOHQ PX HLQ ]ZHLWHU 3DUDPHWHU DQJHJHEHQ ZHUGHQ GHU GLH $Q]DKO GHU HLQ]XOHVHQGHQ =HLFKHQ DQJLEW char s[100]; // Variable zur Aufnahme von 99 Zeichen deklarieren + \0 cin.get(s, 40); // maximal 40 Zeichen einlesen 'LH (LQJDEH HLQHV 6WULQJV ZLUG GXUFK GDV %HWlWLJHQ YRQ RETURN EHHQGHW 'DV %HWlWLJHQ GHU RETURN 7DVWH EHZLUNW DOOHUGLQJV DXFK GD GDV =HLFKHQ \n LQ GHQ (LQJDEHSXIIHU JHVWHOOW ZLUG :HU GHQ 6WULQJV PLWWHOV get JHOHVHQ ZLUG GHU 6WULQJ DXWRPDWLVFK PLW \0 DEJHVFKORVVHQ 'DV =HLFKHQ \n EOHLEW MHGRFK LP (LQJDEHSXIIHU XQG PX EHLVSLHOVZHLVH PLW cin.ignore EHUOHVHQ ZHUGHQ 6RQVW Z UGHQ 6LH EHLP QlFKVWHQ $XIUXI HLQHU (LQJDEHIXQNWLRQ GLHVHV =HLFKHQ HUKDOWHQ (LQH $OWHUQDWLYH VWHOOW GLH )XQNWLRQ getline GDU char str[100]; // Variable zur Aufnahme von 99 Zeichen deklarieren + \0 int i = 40; // maximale Länge soll 40 Zeichen sein (ohne '\0') cin.getline (str, i); // liest einen String mit abschließenden '\n' aus 'LH 3DUDPHWHU HQWVSUHFKHQ GHQHQ YRQ cin.get(s,n) hehu getline ZLUG GDV =HLFKHQ '\n' HEHQIDOOV JHOH VHQ XQG DXV GHP (LQJDEHSXIIHU HQWIHUQW 'LHVHV =HLFKHQ ZLUG DEHU QLFKW LQ str JHVSHLFKHUW VRQGHUQ GXUFK GDV 6WULQJHQGH]HLFKHQ '\0' HUVHW]W

Streams 3 3.4 Übung 6FKUHLEHQ 6LH HLQ 3URJUDPP GDV DP %LOGVFKLUP,KUHQ 1DPHQ DOV %DQQHU DXVJLEW ]% * * ***** **** *** ***** ***** ***** ***** * * * * * ***** * * * * * 5HDOLVLHUHQ 6LH HLQH $XVJDEH HLQHU 5HFKQXQJ PLW EHOLHELJHQ 3RVLWLRQHQ XQG HLQHU DEVFKOLH HQGHQ 6XPPHQDQJDEH bqghuq 6LH GDV %HLVSLHO I U GLH )XQNWLRQ ignore 4XDGUDW HLQHU =DKO DXVJHEHQ ZHLWHU REHQ VR DE GD YRU (QGH GHV 3URJUDPPV DXI HLQH (LQJDEH JHZDUWHW ZLUG 6FKUHLEHQ 6LH HLQ 3URJUDPP GDV YRQ HLQHP $QZHQGHU HLQJHJHEHQH 'DWHQ HLQHU 3URGXNWOLVWH IRUPDWLHUW DXVJLEW (LQJHJHEHQ ZHUGHQ VROOHQ GLH $UWLNHOQXPPHU GHU $UWLNHOQDPH GHU ( LQ NDXIVSUHLV XQG GHU 9HUNDXIVSUHLV 'LH $XVJDEH VROO DXI IROJHQGH :HLVH HUIROJHQ $UWLNHOQXPPHU VWHOOLJ OLQNVE QGLJ /HHU]HLFKHQ $UWLNHOQDPH VWHOOLJ OLQNVE QGLJ /HHU]HLFKHQ (LQNDXIVSUHLV VWHOOLJ UHFKWVE QGLJ 1DFKNRPPDVWHOOHQ /HHU]HLFKHQ 9HUNDXIVSUHLV VWHOOLJ UHFKWVE QGLJ 1DFKNRPPDVWHOOHQ ]% 000201 Seife 10.12 12.00 001204 Feinfrostspinat 123.00 140.50 Notizen