Verfügbarkeit: C, C++ | Technische Universität München

Gespeichert in:

Bibliographische Detailangaben
Beteiligte Personen:	Kaiser, Ulrich (VerfasserIn), Kecher, Christoph (VerfasserIn)
Format:	Buch
Sprache:	Deutsch
Veröffentlicht:	Bonn Galileo Press 2008
Ausgabe:	4., aktualisierte und erw. Aufl.
Schriftenreihe:	Galileo Computing
Schlagwörter:	C++ C > Programmiersprache Aufgabensammlung
Links:	http://deposit.dnb.de/cgi-bin/dokserv?id=3117168&prov=M&dok_var=1&dok_ext=htm http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=016702295&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
Beschreibung:	Auch unveränd. Nachdr. vorhanden Hier auch später erschienene, unveränderte Nachdrucke
Umfang:	1344 S. Ill., graph. Darst. 1 CD-ROM (12 cm)
ISBN:	9783898428392 3898428397

Internformat

MARC


LEADER	00000nam a2200000 c 4500
001	BV035033353
003	DE-604
005	20240517
007	t\|
008	080902s2008 xx ad\|\| \|\|\|\| 00\|\|\| ger d
015			\|a 08,N24,0033 \|2 dnb
016	7		\|a 98891834X \|2 DE-101
020			\|a 9783898428392 \|c Gb. : sfr 67.90 (freier Pr.), EUR 39.90, EUR 41.10 (AT) \|9 978-3-89842-839-2
020			\|a 3898428397 \|9 3-89842-839-7
035			\|a (OCoLC)255069698
035			\|a (DE-599)DNB98891834X
040			\|a DE-604 \|b ger \|e rakddb
041	0		\|a ger
049			\|a DE-91G \|a DE-1051 \|a DE-Aug4 \|a DE-1046 \|a DE-859 \|a DE-29T \|a DE-523 \|a DE-862 \|a DE-19 \|a DE-573 \|a DE-355
082	0		\|a 005.133 \|2 22/ger
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
084			\|a 004 \|2 sdnb
084			\|a DAT 358f \|2 stub
100	1		\|a Kaiser, Ulrich \|e Verfasser \|0 (DE-588)132697122 \|4 aut
245	1	0	\|a C, C++ \|b [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil] \|c Ulrich Kaiser ; Christoph Kecher
250			\|a 4., aktualisierte und erw. Aufl.
264		1	\|a Bonn \|b Galileo Press \|c 2008
300			\|a 1344 S. \|b Ill., graph. Darst. \|e 1 CD-ROM (12 cm)
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
490	0		\|a Galileo Computing
500			\|a Auch unveränd. Nachdr. vorhanden
500			\|a Hier auch später erschienene, unveränderte Nachdrucke
650	0	7	\|a C++ \|0 (DE-588)4193909-8 \|2 gnd \|9 rswk-swf
650	0	7	\|a C \|g Programmiersprache \|0 (DE-588)4113195-2 \|2 gnd \|9 rswk-swf
655		7	\|0 (DE-588)4143389-0 \|a Aufgabensammlung \|2 gnd-content
689	0	0	\|a C \|g Programmiersprache \|0 (DE-588)4113195-2 \|D s
689	0		\|5 DE-604
689	1	0	\|a C++ \|0 (DE-588)4193909-8 \|D s
689	1		\|5 DE-604
700	1		\|a Kecher, Christoph \|e Verfasser \|0 (DE-588)124233511 \|4 aut
856	4	2	\|q text/html \|u http://deposit.dnb.de/cgi-bin/dokserv?id=3117168&prov=M&dok_var=1&dok_ext=htm \|3 Inhaltstext
856	4	2	\|m HBZ Datenaustausch \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=016702295&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
943	1		\|a oai:aleph.bib-bvb.de:BVB01-016702295

Datensatz im Suchindex

DE-BY-TUM_call_number	0104 DAT 358f 2005 A 9116(4) 0303 DAT 358f 2005 L 738(4)
DE-BY-TUM_katkey	1642582
DE-BY-TUM_location	01 03
DE-BY-TUM_media_number	040010140042 040071290074 040071290085 040071290110 040071290132 040071290041
DE-BY-UBR_call_number	14/ST 250 C01 K13
DE-BY-UBR_katkey	5731768
DE-BY-UBR_location	UB Allgemeiner Lesesaal
DE-BY-UBR_media_number	069039571159
_version_	1835096756180746240
adam_text	Auf einen Blick 1 Einige Grundbegriffe ..................................................................... 21 2 Einführung in die Programmierung ............................................... 35 3 Ausgewählte Sprachelemente von C ............................................. 43 4 Arithmetik ..................................................................................... 73 5 Aussagenlogik ............................................................................... 97 6 Elementare Datentypen und ihre Darstellung............................... 129 7 AAodularisierung ............................................................................ 181 8 Zeiger und Adressen ...................................................................... 253 9 C-Referenz (Teil 1) ......................................................................... 271 10 Kombinatorik ................................................................................ 315 11 Leistungsanalyse und-messung von Algorithmen........................ 349 12 Sortierverfahren ............................................................................. 395 13 Datenstrukturen ............................................................................ 441 14 C-Referenz (Teil 2) ......................................................................... 497 15 Ausgewählte Datenstrukturen ...................................................... 519 16 Elemente der Graphentheorie ....................................................... 613 17 Projekt 2D-Grafikprogrammierung ............................................... 701 18 C++-Referenz (Teil 1) ..................................................................... 703 19 Objektorientierte Programmierung............................................... 743 20 Klassen in C++ ............................................................................... 759 21 Vererbung in C++........................................................................... 823 22 C++- Referenz (Teil 2) ..................................................................... 893 23 Die C++-Standard-Library ............................................................. 983 24 Projekt: 3D-Grafikprogrammierung .............................................. 1077 Anhang........................................................................................... 1079 Lösungen ....................................................................................... 1083 Inhalt Vorwort ................................................................................................. 17 Danksagung ........................................................................................... 18 Vorwort zur zweiten Auflage .................................................................. 19 Vorwort zur vierten Auflage ................................................................... 20 1.1 Algorithmus................................................................................. 23 1.2 Datenstruktur .............................................................................. 27 1.3 Programm.................................................................................... 29 1.4 Aufgaben ..................................................................................... 32 2.1 Die Programmierumgebung ......................................................... 40 2.1.1 Der Editor ..................................................................... 40 2.1.2 DerCompiler ................................................................ 41 2.1.3 Der Linker..................................................................... 42 2.1.4 Der Debugger ............................................................... 42 3.1 Programmrahmen ........................................................................ 43 3.2 Zahlen ......................................................................................... 44 3.3 Variablen ..................................................................................... 44 3.4 Operationen ................................................................................ 46 3.4.1 Zuweisungsoperationen ................................................ 46 3.4.2 Rechenoperationen ....................................................... 47 3.4.3 Vergleichsoperationen .................................................. 49 3.5 Kommentare................................................................................ 49 3.6 Elementare Ein-/Ausgabe ............................................................. 50 3.6.1 Bildschirmausgabe ........................................................ 50 3.6.2 Tastatureingabe ............................................................ 52 3.7 Kontrollfluss ................................................................................ 52 3.7.1 Bedingte Befehlsausführung .......................................... 53 3.7.2 Wiederholte Befehlsausführung..................................... 54 3.7.3 Verschachtelung von Kontrollstrukturen........................ 60 3.8 Beispiele ...................................................................................... 61 3.8.1 Das erste C-Programm .................................................. 61 4 Arithmetik...... 3.8.2 Das zweite C-Programm ................................................ 62 3.8.3 Das dritte C-Programm ................................................. 66 3.9 Aufgaben ..................................................................................... 69 33329 4.1 Folgen ......................................................................................... 7i 4.2 Summen ...................................................................................... 80 4.3 Produkte ..................................................................................... 87 4.4 Aufgaben ..................................................................................... 89 1 5.1 Aussagen ..................................................................................... 97 5.2 Logische Operatoren ................................................................... 98 5.3 Darstellung boolescher Funktionen .............................................. 106 5.4 Vereinfachung boolescher Ausdrücke........................................... 111 5.5 Logische Operatoren in C ............................................................ 119 5.6 Programmierbeispiele .................................................................. 120 5.6.1 Kugelspiel ..................................................................... 120 5.6.2 Schaltung...................................................................... 121 5.7 Aufgaben ..................................................................................... 124 6.1 Zahlendarstellungen .................................................................... 129 6.1.1 Dezimaldarstellung ....................................................... 131 6.1.2 Dualdarstellung............................................................. 131 6.1.3 Oktaldarstellung ........................................................... 133 6.1.4 Hexadezimaldarstellung ................................................ 134 6.2 Bits und Bytes.............................................................................. 136 6.3 Skalare Datentypen in C............................................................... 140 6.3.1 Ganze Zahlen ................................................................ 141 6.3.2 Aufzählungstypen ......................................................... 142 6.3.3 Gleitkommazahlen ........................................................ 142 6.3.4 Buchstaben .................................................................. 143 6.4 Bit-Operationen.......................................................................... 147 6.5 Programmierbeispiele mit Zeichen, Zahlen und Bit-Operationen........................................................................... -]5q 6.5.1 Zeichensatz........................................................... 150 6.5.2 Bit-Editor...................................................................... 152 5 Aussagenlogik .......... 181 6.6 Arrays und Zeichenketten ............................................................ 156 6.6.1 Arrays ........................................................................... 156 6.6.2 Zeichenketten ............................................................... 161 6.7 Programmierbeispiele mit Arrays und Strings ............................... 167 6.7.1 Buchstaben zählen ........................................................ 167 6.7.2 Matrixdruck .................................................................. 170 6.8 Aufgaben ..................................................................................... 173 7.1 Funktionen und Unterprogramme................................................ 181 7.2 Rekursion .................................................................................... 188 7.3 Der Stack..................................................................................... 196 7.4 Globale, lokale und statische Variablen ........................................ 199 7.5 Die C-Runtime-Library................................................................. 201 7.5.1 Mathematische Funktionen........................................... 201 7.5.2 Konvertierungs- und Klassifizierungsroutinen ................ 204 7.5.3 Stringbearbeitung ......................................................... 206 7.5.4 Terminall/O ................................................................. 208 7.5.5 Dateioperationen .......................................................... 213 7.5.6 Suchen und Sortieren .................................................... 216 7.5.7 Variable Anzahl von Argumenten .................................. 216 7.5.8 Ausnahme-und Fehlerbehandlung................................ 219 7.5.9 Assertions und Programmabbruch ................................. 223 7.5.10 Freispeicherverwaltung und Speicherfunktionen............ 225 7.5.11 Zeit-und Datum-Funktionen ........................................ 225 7.5.12 Prozess-Steuerung......................................................... 226 7.6 Beispiele ...................................................................................... 226 7.6.1 Das Damenproblem ...................................................... 226 7.6.2 Labyrinth ...................................................................... 234 7.7 Aufgaben ..................................................................................... 240 8.1 Zeigerarithmetik .......................................................................... 257 8.2 Arrays und Zeiger......................................................................... 259 8.3 Funktionszeiger ........................................................................... 262 8.4 Komplexe Variablendeklarationen................................................ 266 8.5 Aufgaben ..................................................................................... 268 9 C-Referenz (Teil 1) ... 9.1 Reservierte Wörter ...................................................................... 271 9.2 Identifier ..................................................................................... 271 9.3 Numerische Werte....................................................................... 272 9.4 Werte für Zeichen und Zeichenketten .......................................... 273 9.5 Skalare Datentypen...................................................................... 274 9.6 Variablen ..................................................................................... 274 9.7 Arrays .......................................................................................... 279 9.8 Operatoren .................................................................................. 279 9.8.1 Arithmetische Operatoren ............................................. 284 9.8.2 Vergleichsoperatoren .................................................... 285 9.8.3 Logische Operatoren ..................................................... 285 9.8.4 Bit-Operatoren ............................................................. 286 9.8.5 Zugriffsoperatoren......................................................... 286 9.8.6 Auswertungsoperatoren ................................................ 287 9.8.7 Datentyp-Operatoren ................................................... 288 9.8.8 Ausdrücke und Zuweisungsoperatoren .......................... 289 9.9 Funktionen .................................................................................. 293 9.10 Kontrollstrukturen ....................................................................... 295 9.10.1 Alternativen .................................................................. 295 9.10.2 Sprungleisten ................................................................ 296 9.10.3 Schleifen ....................................................................... 298 9.10.4 Sprunganweisungen ...................................................... 300 9.11 Der Preprozessor ......................................................................... 302 9.11.1 Includes ........................................................................ 302 9.11.2 Symbolische Konstanten ............................................... 303 9.11.3 Makros ......................................................................... 305 9.11.4 Bedingte Compilierung.................................................. 306 9.12 Der Aufbau von Programmdateien ............................................... 308 9.12.1 Header-Dateien ............................................................ 309 9.12.2 Quellcode-Dateien........................................................ 310 9.13 Einige Coding-Standards .............................................................. 311 10.1 Kombinatorische Grundaufgaben ................................................. 316 10.1.1 Permutationen mit Wiederholungen ............................. 316 10.1.2 Permutationen ohne Wiederholungen........................... 317 10.1.3 Kombinationen ohne Wiederholungen.......................... 318 10.1.4 Kombinationen mit Wiederholungen ............................ 320 10.1.5 Zusammenfassung......................................................... 322 10.2 Kombinatorische Algorithmen ..................................................... 324 10.2.1 Permutationen mit Wiederholungen ............................. 325 10.2.2 Kombinationen mit Wiederholungen ............................ 328 10.2.3 Kombinationen ohne Wiederholungen .......................... 330 10.2.4 Permutationen ohne Wiederholungen ........................... 332 10.3 Beispiele ...................................................................................... 335 10.3.1 Juwelenraub.................................................................. 335 10.3.2 Geldautomat................................................................. 340 10.4 Aufgaben ..................................................................................... 345 11.1 Leistungsanalyse .......................................................................... 352 11.2 Leistungsmessung........................................................................ 364 11.2.1 Überdeckungsanalyse.................................................... 366 11.2.2 Performance-Analyse .................................................... 367 11.3 Mathematische Grundfunktionen................................................. 369 11.3.1 Floor und Ceiling .......................................................... 369 11.3.2 Potenzfunktionen .......................................................... 371 11.3.3 Exponentialfunktionen .................................................. 372 11.3.4 Logarithmen ................................................................. 373 11.4 Laufzeitklassen ............................................................................. 375 11.5 Beispiele ...................................................................................... 382 12.1 Bubblesort................................................................................... 396 12.2 Selectionsort................................................................................ 398 12.3 Insertionsort ................................................................................ 401 12.4 Shellsort ...................................................................................... 403 12.5 Quicksort..................................................................................... 407 12.6 Heapsort...................................................................................... 412 12.7 Leistungsanalyse .......................................................................... 418 12.7.1 Bubblesort .................................................................... 420 12.7.2 Selectionsort ................................................................. 421 12.7.3 Insertionsort ................................................................. 423 12.7.4 Shellsort........................................................................ 424 12.7.5 Quicksort ...................................................................... 425 12.7.6 Heapsort....................................................................... 427 12.8 Vergleich und Bewertung............................................................. 428 12.9 Grenzen der Optimierung von Sortierverfahren ............................ 434 12.10 Aufgaben 439 13 Datenstrukturen............................................. 13.1 Datensequenz (struct) .................................................................. 444 13.2 Datenalternative (union) .............................................................. 451 13.3 Optimierung von Datenstrukturen ............................................... 457 13.4 Zeiger und Datenstrukturen ......................................................... 462 13.5 Dynamische Datenstrukturen ....................................................... 465 13.6 Verkettete Datenstrukturen (Listen) ............................................. 470 13.7 Die Freispeicherverwaltung.......................................................... 474 13.8 Abstrakte Datentypen .................................................................. 478 13.8.1 Der abstrakte Datentyp »Stack«..................................... 480 13.8.2 Der abstrakte Datentyp »Queue« .................................. 485 13.9 Aufgaben ..................................................................................... 490 14 C-Referenz (Teil 2)....................................................................497 14.1 Einfache Strukturen ..................................................................... 497 14.2 Zusammengesetzte Strukturen ..................................................... 500 14.3 Zugriff auf Strukturen................................................................... 502 14.3.1 Direkter Zugriff ............................................................. 502 14.3.2 Indirekter Zugriff........................................................... 503 14.4 Unions ......................................................................................... 505 14.5 Datenstrukturen und Funktionen ................................................. 506 14.6 Dynamische Datenstrukturen ....................................................... 509 14.7 Zeiger in Datenstrukturen ............................................................ 511 14.8 Typvereinbarungen ...................................................................... 515 14.9 Bitfelder ...................................................................................... 516 15 Ausgewählte Datenstrukturen................................................. S19 15.1 Aufgabenstellung......................................................................... 519 15.2 Schnittstellenvereinbarung........................................................... 521 15.3 Anwendungsprogramm................................................................ 524 15.4 Listen .......................................................................................... 530 15.4.1 Grundbegriffe................................................................ 530 15.4.2 Arrays oder Listen ......................................................... 532 15.4.3 Speicherstruktur............................................................ 533 15.4.4 Implementierung .......................................................... 537 15.4.5 Test .............................................................................. 542 15.5 Bäume ......................................................................................... 543 15.5.1 Grundbegriffe................................................................ 543 15.5.2 Traversierung von Bäumen ............................................ 547 15.5.3 Speicherstruktur............................................................ 559 15.5.4 Implementierung .......................................................... 562 15.5.5 Test .............................................................................. 569 15.6 Ausgeglichene Bäume .................................................................. 570 15.6.1 Grundbegriffe................................................................ 571 15.6.2 Speicherstruktur............................................................ 575 15.6.3 Implementierung .......................................................... 578 15.6.4 Test .............................................................................. 592 15.7 Hashtabeilen................................................................................ 593 15.7.1 Grundbegriffe................................................................ 594 15.7.2 Speicherstruktur............................................................ 596 15.7.3 Implementierung .......................................................... 599 15.7.4 Test .............................................................................. 602 15.8 Vergleich und Bewertung............................................................. 606 15.8.1 Speicherkomplexität...................................................... 606 15.8.2 Laufzeitmessungen ........................................................ 607 15.9 Aufgaben ..................................................................................... 612 16.1 Grundbegriffe .............................................................................. 615 16.2 Darstellung von Graphen durch Datenstrukturen ......................... 621 16.3 Ausgewählte graphentheoretische Probleme................................ 627 16.3.1 Existenz von Wegen ...................................................... 629 16.3.2 Kürzeste Wege .............................................................. 649 16.3.3 Minimal spannende Bäume ........................................... 682 16.3.4 Hamiltonsche Wege ...................................................... 688 i :$*5qjiirä^^ 18 ¦ C-H-Referenz (Teil K) 18.1 Schlüsselwörter............................................................................ 703 18.2 Operatoren .................................................................................. 704 18.3 Kommentare................................................................................ 707 18.4 Datentypen, Datenstrukturen und Variablen ................................ 708 18.4.1 Automatische Typisierung von Aufzählungstypen .......... 708 18.4.2 Automatische Typisierung von Strukturen ..................... 708 18.4.3 Vorwärtsverweise auf Strukturen ................................... 709 18.4.4 Der Datentyp bool ........................................................ 710 18.4.5 Wide Character............................................................. 711 18.4.6 Const-Deklarationen ..................................................... 712 18.4.7 Typumwandlungen ....................................................... 713 18.4.8 Definition von Variablen ............................................... 716 18.4.9 Referenzen.................................................................... 716 18.5 Funktionen und Operatoren ........................................................ 722 18.5.1 Funktionsdeklarationen und Prototypen........................ 722 18.5.2 Default-Werte............................................................... 722 18.5.3 tnline-Funktionen ......................................................... 724 18.5.4 Der Scope-Resolution-Operator .................................... 725 18.5.5 Überladen von Funktionen............................................ 726 18.5.6 Überladen von Operatoren ........................................... 728 18.5.7 Einbindung von C-Funktionen in C++-Programme......... 730 18.6 Namensräume ............................................................................. 732 18.6.1 Erstellung von Namensräumen ...................................... 733 18.6.2 Verwendung von Namensräumen ................................. 736 18.6.3 Der Namensraum std .................................................... 740 19 Objektorientierte Programmierung ....................743 20 Klassen in C++................................ .....................759 20.1 Aufbau von Klassen ..................................................................... 759 20.1.1 Daten-Member ............................................................. 761 20.1.2 Funktions-Member ....................................................... 764 20.1.3 Konstruktoren und Destruktoren................................... 772 20.2 Instantiierung von Klassen ........................................................... 777 20.2.1 Automatische Instantiierung ......................................... 779 20.2.2 Statische Instantiierung................................................. 781 20.2.3 Dynamische Instantiierung............................................ 782 20.2.4 Instantiierung von Arrays .............................................. 784 20.3 Friends ........................................................................................ 785 20.4 Operatoren auf Klassen................................................................ 788 20.5 Ein-und Ausgabe in C++ ............................................................. 792 20.5.1 Bildschirmausgabe ........................................................ 793 20.5.2 Tastatureingabe ............................................................ 796 20.5.3 Dateioperationen .......................................................... 797 20.6 Der this-Pointer ........................................................................... 799 20.7 Beispiele ...................................................................................... 800 20.7.1 Menge .......................................................................... 800 20.7.2 Bingo ............................................................................ 811 20.8 Aufgaben ..................................................................................... 818 21.1 Geschützte Member .................................................................... 829 21.2 Einfache Vererbung ..................................................................... 832 21.3 Mehrfache Vererbung .................................................................. 833 21.4 Instantiierung abgeleiteter Klassen............................................... 833 21.5 Erweiterung abgeleiteter Klassen ................................................. 835 21.6 Überladen von Funktionen der Basisklasse ................................... 836 21.7 Virtuelle Member-Funktionen...................................................... 841 21.8 Rein virtuelle Member-Funktionen .............................................. 844 21.9 Statische Member........................................................................ 845 21.10 Beispiele ...................................................................................... 850 21.10.1 Würfelspiel ................................................................... 850 21.10.2 Partnervermittlung........................................................ 871 22.1 Klassen und Instanzen ................................................................. 893 22.2 Member ...................................................................................... 894 22.2.1 Daten-Member ............................................................. 895 22.2.2 Funktions-Member ....................................................... 896 22.2.3 Konstante Member ....................................................... 899 22.2.4 Statische Member ......................................................... 900 22.2.5 Operatoren ................................................................... 902 22.3 Zugriff auf Member...................................................................... 903 22.3.1 Zugriff von außen .......................................................... 904 22.3.2 Zugriff von innen........................................................... 907 22.3.3 Der this-Pointer ............................................................ 910 22.3.4 Zugriff durch Friends ..................................................... 911 22.4 Vererbung ................................................................................... 913 22.4.1 Einfachvererbung .......................................................... 913 22.4.2 Mehrfach Vererbung....................................................... 917 22.4.3 Virtuelle Funktionen ..................................................... 922 22.4.4 Virtuelle Destruktoren................................................... 925 22.4.5 Rein virtuelle Funktionen .............................................. 926 22.4.6 Dynamische Typüberprüfungen ..................................... 928 22.4.7 Dynamische Typumwandlung........................................ 929 22.5 Zugriffsschutz und Vererbung ...................................................... 935 22.5.1 Geschützte Member...................................................... 936 22.5.2 Zugriff auf die Basisklasse .............................................. 937 22.5.3 Modifikation von Zugriffsrechten .................................. 941 22.6 Der Lebenszyklus von Objekten ................................................... 942 22.6.1 Konstruktion von Objekten ........................................... 945 22.6.2 Destruktion von Objekten............................................. 948 22.6.3 Kopieren von Objekten ................................................. 949 22.6.4 Instantiierung von Objekten.......................................... 953 22.6.5 Implizite und explizite Verwendung von Konstruktoren............................................................... 956 22.6.6 Initialisierung eingelagerter Objekte.............................. 957 22.6.7 Initialisierung von Basisklassen ...................................... 960 22.6.8 Initialisierung virtueller Basisklassen .............................. 962 22.6.9 Instantiierungsregeln..................................................... 964 22.7 Pointer to Member ...................................................................... 966 22.8 Generische Klassen (Templates) ................................................... 970 22.9 Ausnahmefallbehandlung............................................................. 976 23 Die C++-Standard-Library........................................................983 23.1 Iteratoren .................................................................................... 984 23.2 Strings (string) ............................................................................. 987 23.2.1 Konstruktion ................................................................. 988 23.2.2 Ein-/Ausgabe ................................................................ 989 23.2.3 Zugriff........................................................................... 989 23.2.4 Manipulation ................................................................ 992 23.2.5 Vergleich ...................................................................... 997 23.2.6 Suchen.......................................................................... 998 23.2.7 Speichermanagement.................................................... 999 23.3 Bitsets (bitset)..............................................................................-J002 23.3.1 Konstruktion .................................................................1002 23.3.2 Zugriff...........................................................................1003 23.3.3 Manipulation ................................................................1004 23.4 Dynamische Arrays (vector)..........................................................1005 23.4.1 Konstruktion .......................................................... 1006 23.4.2 Zugriff...........................................................................1007 1A 23.4.3 Iteratoren......................................................................1008 23.4.4 Manipulation ................................................................1009 23.4.5 Speichermanagement....................................................1012 23.5 Beidseitige Warteschlangen (deque) ............................................1012 23.6 Listen (list) ...................................................................................1014 23.6.1 Konstruktion .................................................................1014 23.6.2 Zugriff...........................................................................1015 23.6.3 Iteratoren......................................................................1015 23.6.4 Manipulation ................................................................1017 23.6.5 Speichermanagement....................................................1027 23.7 Stacks (stack) ...............................................................................1027 23.8 Warteschlangen (queue) ..............................................................1030 23.9 Prioritätswarteschlangen (priority_queue) ....................................1032 23.10 Geordnete Paare (pair) .................................................................1038 23.11 Mengen (set und multiset)...........................................................1040 23.11.1 Konstruktion .................................................................1041 23.11.2 Zugriff...........................................................................1042 23.11.3 Manipulation ................................................................1044 23.12 Relationen (map und multimap) ..................................................1045 23.12.1 Konstruktion .................................................................1046 23.12.2 Zugriff...........................................................................1049 23.12.3 Manipulation ................................................................1049 23.13 Algorithmen der Standard-Library ................................................1049 23.13.1 Iterieren ........................................................................1052 23.13.2 Suchen und Finden .......................................................1053 23.13.3 Vergleichen...................................................................1055 23.13.4 Zählen...........................................................................1056 23.13.5 Kopieren .......................................................................1057 23.13.6 Tauschen ......................................................................1058 23.13.7 Ersetzen ........................................................................1059 23.13.8 Wertzuweisung .............................................................1061 23.13.9 Entfernen von Elementen ..............................................1062 23.13.10 Reorganisation ..............................................................1063 23.13.11 Sortieren .......................................................................1064 23.13.12 Binäre Suche .................................................................1065 23.13.13 Mischen ........................................................................1066 23.13.14Mengenoperationen .....................................................1067 23.13.15 Heap-Algorithmen ........................................................1069 23.13.16Minima und Maxima.....................................................1070 23.13.17 Lexikografische Ordnung und Permutationen ................1071 23.14 Vererbung und virtuelle Funktionen in Containern.......................1073 24 Projekt: 3D-Crafikprogrammierung ....................1077 .....................1079 Anhang.................................................. Lösungen...................................................................................................... 1083 Kapitell ...................................................................................... 1085 Kapitel 3...................................................................................... 1103 Kapitel 4...................................................................................... 1123 Kapitel 5...................................................................................... 1155 Kapitel 6...................................................................................... 1169 Kapitel 7...................................................................................... 1195 Kapitel 8...................................................................................... 1245 Kapitel 10..................................................................................... 1253 Kapitel 12..................................................................................... 1273 Kapitel 13..................................................................................... 1277 Kapitel 15..................................................................................... 1305 Kapitel 20..................................................................................... 1315 Index ........................................................................................................... 1333
any_adam_object	1
author	Kaiser, Ulrich Kecher, Christoph
author_GND	(DE-588)132697122 (DE-588)124233511
author_facet	Kaiser, Ulrich Kecher, Christoph
author_role	aut aut
author_sort	Kaiser, Ulrich
author_variant	u k uk c k ck
building	Verbundindex
bvnumber	BV035033353
classification_rvk	ST 250
classification_tum	DAT 358f
ctrlnum	(OCoLC)255069698 (DE-599)DNB98891834X
dewey-full	005.133
dewey-hundreds	000 - Computer science, information, general works
dewey-ones	005 - Computer programming, programs, data, security
dewey-raw	005.133
dewey-search	005.133
dewey-sort	15.133
dewey-tens	000 - Computer science, information, general works
discipline	Informatik
edition	4., aktualisierte und erw. Aufl.
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>02323nam a2200505 c 4500</leader><controlfield tag="001">BV035033353</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20240517 </controlfield><controlfield tag="007">t\|</controlfield><controlfield tag="008">080902s2008 xx ad\|\| \|\|\|\| 00\|\|\| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">08,N24,0033</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">98891834X</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783898428392</subfield><subfield code="c">Gb. : sfr 67.90 (freier Pr.), EUR 39.90, EUR 41.10 (AT)</subfield><subfield code="9">978-3-89842-839-2</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3898428397</subfield><subfield code="9">3-89842-839-7</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)255069698</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB98891834X</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rakddb</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">ger</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-91G</subfield><subfield code="a">DE-1051</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-1046</subfield><subfield code="a">DE-859</subfield><subfield code="a">DE-29T</subfield><subfield code="a">DE-523</subfield><subfield code="a">DE-862</subfield><subfield code="a">DE-19</subfield><subfield code="a">DE-573</subfield><subfield code="a">DE-355</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.133</subfield><subfield code="2">22/ger</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 358f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Kaiser, Ulrich</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)132697122</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">C, C++</subfield><subfield code="b">[das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil]</subfield><subfield code="c">Ulrich Kaiser ; Christoph Kecher</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">4., aktualisierte und erw. Aufl.</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Bonn</subfield><subfield code="b">Galileo Press</subfield><subfield code="c">2008</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1344 S.</subfield><subfield code="b">Ill., graph. Darst.</subfield><subfield code="e">1 CD-ROM (12 cm)</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="490" ind1="0" ind2=" "><subfield code="a">Galileo Computing</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Auch unveränd. Nachdr. vorhanden</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Hier auch später erschienene, unveränderte Nachdrucke</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">C++</subfield><subfield code="0">(DE-588)4193909-8</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">C</subfield><subfield code="g">Programmiersprache</subfield><subfield code="0">(DE-588)4113195-2</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="655" ind1=" " ind2="7"><subfield code="0">(DE-588)4143389-0</subfield><subfield code="a">Aufgabensammlung</subfield><subfield code="2">gnd-content</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">C</subfield><subfield code="g">Programmiersprache</subfield><subfield code="0">(DE-588)4113195-2</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="1" ind2="0"><subfield code="a">C++</subfield><subfield code="0">(DE-588)4193909-8</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Kecher, Christoph</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)124233511</subfield><subfield code="4">aut</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="q">text/html</subfield><subfield code="u">http://deposit.dnb.de/cgi-bin/dokserv?id=3117168&prov=M&dok_var=1&dok_ext=htm</subfield><subfield code="3">Inhaltstext</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">HBZ Datenaustausch</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=016702295&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="943" ind1="1" ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-016702295</subfield></datafield></record></collection>
genre	(DE-588)4143389-0 Aufgabensammlung gnd-content
genre_facet	Aufgabensammlung
id	DE-604.BV035033353
illustrated	Illustrated
indexdate	2024-12-20T13:18:30Z
institution	BVB
isbn	9783898428392 3898428397
language	German
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-016702295
oclc_num	255069698
open_access_boolean
owner	DE-91G DE-BY-TUM DE-1051 DE-Aug4 DE-1046 DE-859 DE-29T DE-523 DE-862 DE-BY-FWS DE-19 DE-BY-UBM DE-573 DE-355 DE-BY-UBR
owner_facet	DE-91G DE-BY-TUM DE-1051 DE-Aug4 DE-1046 DE-859 DE-29T DE-523 DE-862 DE-BY-FWS DE-19 DE-BY-UBM DE-573 DE-355 DE-BY-UBR
physical	1344 S. Ill., graph. Darst. 1 CD-ROM (12 cm)
publishDate	2008
publishDateSearch	2008
publishDateSort	2008
publisher	Galileo Press
record_format	marc
series2	Galileo Computing
spellingShingle	Kaiser, Ulrich Kecher, Christoph C, C++ [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil] C++ (DE-588)4193909-8 gnd C Programmiersprache (DE-588)4113195-2 gnd
subject_GND	(DE-588)4193909-8 (DE-588)4113195-2 (DE-588)4143389-0
title	C, C++ [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil]
title_auth	C, C++ [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil]
title_exact_search	C, C++ [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil]
title_full	C, C++ [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil] Ulrich Kaiser ; Christoph Kecher
title_fullStr	C, C++ [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil] Ulrich Kaiser ; Christoph Kecher
title_full_unstemmed	C, C++ [das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil] Ulrich Kaiser ; Christoph Kecher
title_short	C, C++
title_sort	c c das umfassende lehrbuch von den grundlagen zur professionellen programmierung von einfachen beispielen zu anspruchsvollen algorithmen das standardwerk fur studium und beruf inkl 250 seiten kommentierter losungsteil
title_sub	[das umfassende Lehrbuch ; von den Grundlagen zur professionellen Programmierung ; von einfachen Beispielen zu anspruchsvollen Algorithmen ; das Standardwerk für Studium und Beruf ; inkl. 250 Seiten kommentierter Lösungsteil]
topic	C++ (DE-588)4193909-8 gnd C Programmiersprache (DE-588)4113195-2 gnd
topic_facet	C++ C Programmiersprache Aufgabensammlung
url	http://deposit.dnb.de/cgi-bin/dokserv?id=3117168&prov=M&dok_var=1&dok_ext=htm http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=016702295&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT kaiserulrich ccdasumfassendelehrbuchvondengrundlagenzurprofessionellenprogrammierungvoneinfachenbeispielenzuanspruchsvollenalgorithmendasstandardwerkfurstudiumundberufinkl250seitenkommentierterlosungsteil AT kecherchristoph ccdasumfassendelehrbuchvondengrundlagenzurprofessionellenprogrammierungvoneinfachenbeispielenzuanspruchsvollenalgorithmendasstandardwerkfurstudiumundberufinkl250seitenkommentierterlosungsteil

Verfügbarkeit

Bestellen (Login erforderlich)

Inhaltsverzeichnis
Paper/Kapitel scannen lassen

Teilbibliothek Mathematik & Informatik

Bestandsangaben von Teilbibliothek Mathematik & Informatik
Signatur:	0104 DAT 358f 2005 A 9116(4)
Exemplar 1	Nicht ausleihbar Am Standort

Teilbibliothek Chemie, Lehrbuchsammlung

Bestandsangaben von Teilbibliothek Chemie, Lehrbuchsammlung
Signatur:	0303 DAT 358f 2005 L 738(4)
Exemplar 1	Ausleihbar Am Standort
Exemplar 2	Ausleihbar Am Standort
Exemplar 3	Ausleihbar Am Standort
Exemplar 4	Ausleihbar Am Standort
Exemplar 5	Ausleihbar Am Standort