Breymann. C++ Einführung und professionelle Programmierung

17.11.2014 Aufrufe
6.3 Schreiben Sie ein Programm zur Multiplikation zweier Matrizen a[n][m] * b[p][q]. Das Ergebnis soll in einer Matrix c[r][s] stehen. Welche Voraussetzungen gelten für die Zeilen- und Spaltenzahlen n, m, p, q, r, s? 6.4 Schreiben Sie zur Ausgabe von dreidimensionalen Arrays eine Template- Funktion Tabellenausgabe3D(Feldtyp T, size_t n) entsprechend dem obigen Muster für zwei Dimensionen. Breymann C++, c○ Hanser Verlag München Inhalt ◭◭ ◭ ◮ ◮◮ 246 zurück Ende

6.5.2 Dynamisch erzeugte mehrdimensionale Arrays Mehrdimensionale Arrays mit konstanter Feldgröße Auf Seite 237 haben Sie die statische Deklaration von mehrdimensionalen Feldern gesehen. Im Abschnitt 6.4 wurden ein Array von int- Zahlen und ein Array von Zeigern auf int dynamisch erzeugt, also zur Laufzeit des Programms. Bedeutung von new: int *pa = new int[4]; new gibt einen Zeiger vom Datentyp »Zeiger auf Typ eines Arrayelements« zurück. D.h. im zweidimensionalen Fall: int (* const p2)[7] = new int [5][7]; new gibt einen Zeiger vom Datentyp »Zeiger auf eine Zeile mit 7 Elementen« zurück. p2 ist ein konstanter Zeiger, der auf die Zeile 0 einer zweidimensionalen Matrix mit 5 Zeilen zu je 7 int-Zahlen verweist. Sein Typ ist konstanter Zeiger auf ein int-Array mit 7 Elementen. Breymann C++, c○ Hanser Verlag München Inhalt ◭◭ ◭ ◮ ◮◮ 247 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: Aufgaben 6.1 Die Äquivalenz von *(

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