Breymann. C++ Einführung und professionelle Programmierung

17.11.2014 Aufrufe
Fall 1) Bezugspunkt() ist geerbt cout

8.4 Überschreiben von Funktionen in abgeleiteten Klassen • bisher: Überschreiben von gleichnamigen Funktionen mit unterschiedlicher Schnittstelle • neu: Überschreiben von Elementfunktionen in abgeleiteten Klassen für Funktionen – mit derselben Bedeutung, aber – mit unterschiedlichem Mechanismus Dieselbe Bedeutung erfordert dieselbe Schnittstelle! Breymann C++, c○ Hanser Verlag München Inhalt ◭◭ ◭ ◮ ◮◮ 315 zurück Ende

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 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: 8.3 Code-Wiederverwendung In den ab

Seite 317 und 318: Am Beispiel der Flächenberechnung

Seite 319 und 320: 8.5.1 Virtuelle Funktionen Wirkung


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 424 und 425: 11.1.2 Bauelemente Container Klasse

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

breymann

hanser

verlag

cout

const

void

objekt

zeiger

klasse

funktion

professionelle

programmierung

vred.bioinf.uni-sb.de

Breymann. C++ Einführung und professionelle Programmierung

Breymann. C++ Einführung und professionelle Programmierung ... Mehr anzeigen Breymann. C++ Einführung und professionelle Programmierung

Template löschen?

Als Template speichern ?

Breymann. C++ Einführung und professionelle Programmierung Breymann. C++ Einführung und professionelle Programmierung