- Seite 1 und 2:
Objektorientierte Programmierung mi
- Seite 3 und 4:
Inhalt 1 Einführung 9 2 Grundlegen
- Seite 5 und 6:
4.3.2 Einbinden vorübersetzter Pro
- Seite 7 und 8:
7.3.2 Stack mit statisch festgelegt
- Seite 9 und 10:
1. Einführung Aufgaben eines Rechn
- Seite 11 und 12:
Klassen Klasse = Beschreibung von O
- Seite 13 und 14:
Kursaufbau • Daten Datentypen, -s
- Seite 15 und 16:
2. Grundlegende Begriffe - das erst
- Seite 17 und 18:
C++ C PASCAL #include #include int
- Seite 19 und 20:
2.2 Einfache Datentypen und Operato
- Seite 21 und 22:
2.2.2 Ganze Zahlen Typische Werte f
- Seite 23 und 24:
Operator Beispiel Bedeutung Kurzfor
- Seite 25 und 26:
Operator Beispiel Bedeutung Bit-Ope
- Seite 27 und 28:
Syntax: Vorzeichen (optional) Vorko
- Seite 29 und 30:
#include #include // math. Biblioth
- Seite 31 und 32:
Strukturierung mit Klammern (). Kla
- Seite 33 und 34:
2.2.5 Zeichen 3 verschiedene Typen:
- Seite 35 und 36:
i = 66; c = static_cast(i); // Typu
- Seite 37 und 38:
2.2.6 Logischer Datentyp Datentyp:
- Seite 39 und 40:
2.2.7 Referenzen Referenz = Verweis
- Seite 41 und 42:
{ // Blockbeginn int a = 1; { // Bl
- Seite 43 und 44:
2.4.2 Auswahl (Selektion, Verzweigu
- Seite 45 und 46:
Auswertung des Bedingungsausdrucks
- Seite 47 und 48:
Bedingungsoperator ?: Bedingung ? A
- Seite 49 und 50:
#include using namespace std; int m
- Seite 51 und 52:
nein ✛ ❄ ❅ ❅ ❅ Bedingun
- Seite 53 und 54:
Schleifen mit do while Wirkung: ✛
- Seite 55 und 56:
typische Anwendung: Eingabe mit Pla
- Seite 57 und 58:
Beispiel: ASCII-Tabelle von 65..69
- Seite 59 und 60:
Beispiel : Fakultät berechnen cout
- Seite 61 und 62:
#include using namespace std; int m
- Seite 63 und 64:
2.3 Fünf Leute haben versucht, die
- Seite 65 und 66:
• schlechter Dokumentationswert :
- Seite 67 und 68:
2.5.2 Arrays: Der C++ Standardtyp v
- Seite 69 und 70:
cout
- Seite 71 und 72:
} sortierteKosten[j] = temp; } // u
- Seite 73 und 74:
Variationen zur Suche in einer Tabe
- Seite 75 und 76:
Vektoren sind dynamisch! vector Vd(
- Seite 77 und 78:
for(size_t i = 0; i < einString.siz
- Seite 79 und 80:
2.5.4 Strukturierte Datentypen zur
- Seite 81 und 82:
3. Einfache Ein- und Ausgabe - Stan
- Seite 83 und 84:
Eingabe Eigenschaften des Eingabeop
- Seite 85 und 86:
Ausgabe automatische Umformung der
- Seite 87 und 88:
Definieren und Öffnen der Ausgabed
- Seite 89 und 90:
4. Programmstrukturierung - Funktio
- Seite 91 und 92:
} // alternativ mit Zwischenablage
- Seite 93 und 94:
Rückgabetyp Funktionsname ( Formal
- Seite 95 und 96:
#include using namespace std; int a
- Seite 97 und 98:
4.2 Schnittstellen zum Datentransfe
- Seite 99 und 100:
Aufrufer-Sicht i symbolischer Name
- Seite 101 und 102:
4.2.2 Übergabe per Referenz In der
- Seite 103 und 104:
Aufrufer-Sicht Speicherzelle i symb
- Seite 105 und 106:
4.2.4 Vorgabewerte und variable Par
- Seite 107 und 108:
4.2.5 Überladen von Funktionen der
- Seite 109 und 110:
4.2.6 Funktion main Varianten: int
- Seite 111 und 112:
4.3 Grundsätze der modularen Gesta
- Seite 113 und 114:
4.3.2 Einbinden vorübersetzter Pro
- Seite 115 und 116:
mainprog.cpp #include "a.h" #includ
- Seite 117 und 118:
Üblich: make-Files oder „Projekt
- Seite 119 und 120:
Beschränkung des Gültigkeitsberei
- Seite 121 und 122:
4.3.4 Übersetzungseinheit, Deklara
- Seite 123 und 124:
one definition rule Jede Variable,
- Seite 125 und 126:
Inhalt von Implementations-Dateien
- Seite 127 und 128:
4.3.5 Compilerdirektiven sind Anwei
- Seite 129 und 130:
Makros mit #define zum Ersetzen von
- Seite 131 und 132:
Eine weitere übliche Anwendung von
- Seite 133 und 134:
Nur mit den Sprachelementen von C++
- Seite 135 und 136:
Verifizieren logischer Annahmen mit
- Seite 137 und 138:
template int kleiner(const T& a, co
- Seite 139 und 140:
* Erst in der folgenden Anweisung w
- Seite 141 und 142:
4.5 inline-Funktionen inline ist ei
- Seite 143 und 144:
5. Objektorientierung 1 - Abstrakte
- Seite 145 und 146:
} // ... Protokollierung Punkt einP
- Seite 147 und 148:
Eigenschaften: • Der Sinn liegt d
- Seite 149 und 150:
class Klassenname { public: Typ Ele
- Seite 151 und 152:
Anwendung: // ort1main.cpp #include
- Seite 153 und 154:
aendern() soll Änderungen der Koor
- Seite 155 und 156:
2. Deklaration und Definition inner
- Seite 157 und 158:
5.3 Initialisierung und Konstruktor
- Seite 159 und 160:
5.3.2 Allgemeine Konstruktoren Allg
- Seite 161 und 162:
Initialisierung mit Listen Beispiel
- Seite 163 und 164:
}; private: int xKoordinate, yKoord
- Seite 165 und 166:
5.3.3 Kopierkonstruktor engl.: copy
- Seite 167 und 168:
Übergabe von Objekten an eine Funk
- Seite 169 und 170:
Zahl bilden int Koordinate = 0; whi
- Seite 171 und 172:
Verhindern impliziter Typwandlungen
- Seite 173 und 174:
Folgende Funktionen sollen von der
- Seite 175 und 176:
Beschränkungen und Hinweise - Kür
- Seite 177 und 178:
Möglichkeiten für Operationen mit
- Seite 179 und 180:
void eingabe(); void ausgabe() cons
- Seite 181 und 182:
5.4.3 Implementation void rational:
- Seite 183 und 184:
void rational::sub(const rational&
- Seite 185 und 186:
long ggt(long x, long y) { // wird
- Seite 187 und 188:
ational mult(const rational& a, con
- Seite 189 und 190:
5.6 Faustregeln zur Konstruktion vo
- Seite 191 und 192:
Regeln: 1. Die geplante Anwendung b
- Seite 193 und 194:
5. Die Art der Übergabe eines Obje
- Seite 195 und 196:
(a) Diese Anweisung wird von links
- Seite 197 und 198:
Natürlich kann von den Empfehlunge
- Seite 199 und 200:
class Beispiel { int zahl; public:
- Seite 201 und 202:
5.8 Wie kommt man zu Klassen und Ob
- Seite 203 und 204:
5.8.1 Einige Analyse-Überlegungen
- Seite 205 und 206:
6. Intermezzo: Zeiger - Zeiger und
- Seite 207 und 208:
. 99 . . 10123 . Adresse Name 10122
- Seite 209 und 210:
int *ip2 = &i; bewirkt: ip ip2 ❩
- Seite 211 und 212:
NULL-Zeiger Eigenschaften: • Ein
- Seite 213 und 214:
. Index 17 35 112 -3 1000 . 0 1 2 3
- Seite 215 und 216:
Zeiger und Arrays Zeiger und Arrays
- Seite 217 und 218:
sizeof funktioniert jedoch nicht be
- Seite 219 und 220:
6.3 C-Zeichenketten C-Zeichenkette
- Seite 221 und 222:
Vordefinierte Funktionen: Header #
- Seite 223 und 224:
char-Arrays // Definition und Initi
- Seite 225 und 226:
Beispiele: Schleifen mit Strings St
- Seite 227 und 228:
Strings kopieren char* original = "
- Seite 229 und 230:
6.4 Dynamische Datenobjekte new: Er
- Seite 231 und 232:
Dynamisch erzeugte Struktur Erzeugu
- Seite 233 und 234:
6.4.1 Freigeben dynamischer Objekte
- Seite 235 und 236:
• Mit new erzeugte Objekte unterl
- Seite 237 und 238:
6.5 Mehrdimensionale C-Arrays 6.5.1
- Seite 239 und 240:
Arrays als Funktionsparameter C-Arr
- Seite 241 und 242:
void Tabellenausgabe2D(int (*T)[3],
- Seite 243 und 244:
Funktion für statische zwei-dimens
- Seite 245 und 246:
Aufgaben 6.1 Die Äquivalenz von *(
- Seite 247 und 248:
6.5.2 Dynamisch erzeugte mehrdimens
- Seite 249 und 250:
Eine dreidimensionale Matrix ist ei
- Seite 251 und 252:
Feld von Zeigern auf Zeilen anlegen
- Seite 253 und 254:
6.6 Binäre Ein-/Ausgabe = unformat
- Seite 255 und 256:
Lesen einer Datei double.dat mit do
- Seite 257 und 258:
void upcase(char* s) { // In der AS
- Seite 259 und 260:
6.7.2 Gefahren bei der Rückgabe vo
- Seite 261 und 262:
int main() { int a = 1700, b = 1000
- Seite 263 und 264:
#include using namespace std; #incl
- Seite 265 und 266:
6.9 this-Zeiger • this ist ein Sc
- Seite 267 und 268:
7. Objektorientierung 2 - eine Stri
- Seite 269 und 270:
const char& at(std::size_t position
- Seite 271 und 272:
7.1.1 friend-Funktionen Optionen f
- Seite 273 und 274:
3. friend-Funktion Falls es aus Lau
- Seite 275 und 276:
• Die static-Funktion Anzahl() so
- Seite 277 und 278:
Implementation der Klasse nummerier
- Seite 279 und 280:
Der Kopierkonstruktor hat hier eine
- Seite 281 und 282:
Der Destruktor vermerkt, dass es nu
- Seite 283 und 284:
Anfang eines neuen Blocks { nummeri
- Seite 285 und 286:
7.2.1 Klassenspezifische Konstante
- Seite 287 und 288:
template class simpleStack { publi
- Seite 289 und 290:
• Der Datentyp T steht für einen
- Seite 291 und 292:
cout
- Seite 293 und 294:
7.3.2 Stack mit statisch festgelegt
- Seite 295 und 296:
Nur die Deklarationen in einem Anwe
- Seite 297 und 298:
8. Vererbung • Eigenschaften, die
- Seite 299 und 300:
Die Unterklasse erbt von der Oberkl
- Seite 301 und 302:
Jedes Objekt ObjA vom Typ A (=abgel
- Seite 303 und 304:
Klasse GraphObj #ifndef graphobj_h
- Seite 305 und 306:
Die Entfernung zwischen 2 GraphObj-
- Seite 307 und 308:
8.1 Vererbung und Initialisierung I
- Seite 309 und 310:
Vererbung von Zugriffsrechten Regel
- Seite 311 und 312:
Oberklasse wird mit der Zugriffsken
- Seite 313 und 314:
8.3 Code-Wiederverwendung In den ab
- Seite 315 und 316:
8.4 Überschreiben von Funktionen i
- Seite 317 und 318:
Am Beispiel der Flächenberechnung
- Seite 319 und 320:
8.5.1 Virtuelle Funktionen Wirkung
- Seite 321 und 322:
cout
- Seite 323 und 324:
GrOptr = &GrO; // Zeiger auf GrO ri
- Seite 325 und 326:
Aus diesen Punkten lässt sich eine
- Seite 327 und 328:
Es gibt Kreise, Rechtecke, Linien,
- Seite 329 und 330:
Bezugspunkt ermitteln Ort Bezugspun
- Seite 331 und 332:
} // leerer Code-Block double Laeng
- Seite 334 und 335:
#ifndef quadrat_h #define quadrat_h
- Seite 336 und 337:
int i = 0; while(GraphObjZeiger[i])
- Seite 338 und 339:
class Abgeleitet : public Basis { /
- Seite 340 und 341:
... immer wenn Basisklassenzeiger o
- Seite 342 und 343:
#ifndef beschrif_h #define beschrif
- Seite 344 und 345:
virtual void zeichnen() const { Rec
- Seite 346 und 347:
8.6.1 Namenskonflikte cout
- Seite 348 und 349:
Subobjekt1: GraphObj Subobjekt2: Gr
- Seite 350 und 351:
eschriftetesRechteck(const Ort &O,
- Seite 352 und 353:
8.6.3 Virtuelle Basisklassen und In
- Seite 354 und 355:
class Unten: public Links, public R
- Seite 356 und 357:
class Unten: public Links, public R
- Seite 358 und 359:
class Rechteck { public: virtual vo
- Seite 360 und 361:
Ohne Vererbung (Delegation): class
- Seite 362 und 363:
8.7.2 Der Teil und das Ganze „Tei
- Seite 364 und 365:
} Bekanntenkreis.Hinzufuegen(&P); S
- Seite 366 und 367:
8.7.4 „Benutzt“-Beziehung Ein O
- Seite 368 und 369:
ReturnDatentyp Klassenname::operato
- Seite 370 und 371:
1. Der Aufruf wird entsprechend der
- Seite 372 und 373:
drei Fälle für gemischte Datentyp
- Seite 374 und 375: Ohne Typumwandlungskonstruktor Um g
- Seite 376 und 377: Mit Typumwandlungskonstruktor Wenn
- Seite 378 und 379: 9.1.2 Ausgabeoperator
- Seite 380 und 381: ✬ ✩ Vektor-Objekt start xDim (=
- Seite 382 und 383: Zuweisungsoperator Vektor& operator
- Seite 384 und 385: template inline void Vektor::init(c
- Seite 386 und 387: Zuweisung von Vektorelementen per W
- Seite 388 und 389: Möglicher Einsatz: Vektor v(5); //
- Seite 390 und 391: template inline Vektor &Vektor::ope
- Seite 392 und 393: 9.2.3 Mathematische Vektoren Vektor
- Seite 394 und 395: 9.2.4 Multiplikations-Operator Anwe
- Seite 396 und 397: * Operator für den Fall v1 = zahl*
- Seite 398 und 399: Um bereits vor der Konstruktion ein
- Seite 400 und 401: void Datum::aktuell() { // Systemda
- Seite 402 und 403: Der Postfix-Inkrementierungsoperato
- Seite 404 und 405: datum.h #include class Datum { // .
- Seite 406 und 407: Es ist sowohl die implizite als auc
- Seite 408 und 409: 3. errno setzen 4. Fehlerbehandlung
- Seite 410 und 411: Wege zur Fehlerbehandlung: • Den
- Seite 412 und 413: gegebenenfalls weitere catch-Blöck
- Seite 414 und 415: 10.1.2 Exception-Hierarchie in C++
- Seite 416 und 417: Breymann C++, c○ Hanser Verlag M
- Seite 418 und 419: Große Teile des Konzepts sind durc
- Seite 420 und 421: 11.1 Die C++ Standardbibliothek, ge
- Seite 422 und 423: 11.1.1 Abstrakte und implizite Date
- Seite 426 und 427: Allen Containern gemeinsam sind auc
- Seite 428 und 429: Iteratoren = Objekte, die auf Eleme
- Seite 430 und 431: Vorhandene Algorithmen: for_each fi
- Seite 432 und 433: } int Zahl = 0; do { cout > Zahl; I
- Seite 434 und 435: Variante 2: Prototyp durch Template
- Seite 436 und 437: } do { cout > Zahl; // Benutzung vo
- Seite 438 und 439: 11.2 Iteratoren im Detail Iteratore
- Seite 440 und 441: 11.2.1 Iteratorkategorien → sind
- Seite 442 und 443: • Random-Access-Iterator wie Bidi
- Seite 444 und 445: Ja. Schwachstelle: • Die Algorith
- Seite 446 und 447: Wie funktioniert dies im einzelnen?
- Seite 448 und 449: 11.2.3 Markierungen und Identifizie
- Seite 450 und 451: 11.3 Zusammenfassung der STL-Eigens
Change language