Verfügbarkeit: Notizen zu C++

Notizen zu C++:

Gespeichert in:

Bibliographische Detailangaben
1. Verfasser:	Thömmes, Peter (VerfasserIn)
Format:	Buch
Sprache:	German
Veröffentlicht:	Berlin [u.a.] Springer 2004
Schriftenreihe:	Xpert.press
Schlagworte:	C++ STL
Online-Zugang:	Inhaltsverzeichnis
Beschreibung:	XIII, 312 S. graph. Darst.
ISBN:	3540010580

Internformat

MARC


LEADER	00000nam a2200000 c 4500
001	BV019381674
003	DE-604
005	20050120
007	t
008	040902s2004 gw d\|\|\| \|\|\|\| 00\|\|\| ger d
016	7		\|a 967073081 \|2 DE-101
020			\|a 3540010580 \|c Pp. : EUR 39.95 \|9 3-540-01058-0
035			\|a (OCoLC)76428558
035			\|a (DE-599)BVBBV019381674
040			\|a DE-604 \|b ger \|e rakddb
041	0		\|a ger
044			\|a gw \|c DE
049			\|a DE-526 \|a DE-11 \|a DE-2070s
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
100	1		\|a Thömmes, Peter \|e Verfasser \|4 aut
245	1	0	\|a Notizen zu C++ \|c Peter Thömmes
264		1	\|a Berlin [u.a.] \|b Springer \|c 2004
300			\|a XIII, 312 S. \|b graph. Darst.
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
490	0		\|a Xpert.press
650	0	7	\|a C++ \|0 (DE-588)4193909-8 \|2 gnd \|9 rswk-swf
650	0	7	\|a STL \|0 (DE-588)4411326-2 \|2 gnd \|9 rswk-swf
689	0	0	\|a C++ \|0 (DE-588)4193909-8 \|D s
689	0		\|5 DE-604
689	1	0	\|a STL \|0 (DE-588)4411326-2 \|D s
689	1		\|5 DE-604
856	4	2	\|m SWB Datenaustausch \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=012844713&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
999			\|a oai:aleph.bib-bvb.de:BVB01-012844713

Datensatz im Suchindex

_version_	1804132825747685376
adam_text	INHALTSVERZEICHNIS 1. EINORDNUNG VON C++ ................................................................................. 1 2. GRUNDSAETZLICHER AUFBAU EINES PROJEKTES................................................. 3 2.1 PRO KLASSE EINE .H UND EINE .CPP-DATEI........................................................... 3 2.2 BENENNUNG VON VERZEICHNISSEN, DATEIEN UND KLASSEN ...................................... 5 2.3 ZENTRALE HEADER-DATEI (SETTINGS.H)..................................................................... 6 2.4 DER CODE MUSS OHNE WARNUNGEN BAUEN ............................................................ 6 2.5 MEHRERE SCHICHTEN VERWENDEN (HORIZONTALE TEILUNG) ........................................ 8 2.6 CLIENT/SERVER-MODELL VERWENDEN (VERTIKALE TEILUNG) ...................................... 10 2.7 DAS BROKER-PATTERN (2-TIER-ARCHITEKTUR), CORBA, DCOM............................ 12 2.7.1 ALLGEMEINES ............................................................................................ 12 2.7.2 IDL-COMPILER ......................................................................................... 15 2.8 CORBA MIT TAO (THE ACE ORB) VON DOUGLAS C. SCHMIDT ........................ 17 2.8.1 ALLGEMEINES ............................................................................................ 17 2.8.2 CODE-BEISPIEL MIT GNU C++-COMPILER UNTER LINUX .......................... 19 2.8.3 CODE-BEISPIEL MIT VISUAL C++ 6.0-COMPILER UNTER WINDOWS-NT ... 32 2.9 UML (UNIFIED MODELING LANGUAGE) ................................................................ 35 2.9.1 ALLGEMEINES ............................................................................................ 35 2.9.2 KARDINALITAETEN NACH UML ....................................................................... 36 2.9.3 FRAGE NACH DEN KLASSEN/OBJEKTEN........................................................... 36 3. WICHTIGE BEGRIFFE UND SPRACHELEMENTE ................................................. 39 3.1 NAMESPACE UND USING........................................................................................ 39 3.2 DEFAULT-KONSTRUKTOR.......................................................................................... 40 3.3 COPY-KONSTRUKTOR............................................................................................. 40 3.4 EXPLICIT-KONSTRUKTOR.......................................................................................... 40 3.5 ZUWEISUNGS-OPERATOR ....................................................................................... 41 3.6 ABSTRAKTE KLASSE (= ABSTRAKTE BASISKLASSE) ...................................................... 42 3.7 DEFAULT-ARGUMENTE........................................................................................... 43 3.8 UNSPEZIFIZIERTE ANZAHL VON ARGUMENTEN ......................................................... 43 3.9 L-VALUE UND R-VALUE............................................................................................ 47 3.10 FUNKTIONSZEIGER .............................................................................................. 48 3.11 UNION ............................................................................................................... 49 3.11.1 ALLGEMEINES ........................................................................................ 49 3.11.2 OBJEKTE UNTERSCHIEDLICHEN TYPS IN EINE SEQUENZ PACKEN (LIST) .......... 49 3.11.3 MEHRERE DATENSTRUKTUREN FUER DIESELBEN DATEN (HARDWAREABHAENGIG)... 51 3.11.4 BITFELDER ZUM ABTASTEN VON BYTE-STREAMS (HARDWAREABHAENGIG) ........ 54 3.11.5 MASKE PER REFERENZ ANWENDEN ........................................................... 56 3.11.6 TEST-FUNKTION ZUM TESTEN DER MASCHINE AUF LITTLE- BZW. BIG-ENDIAN . 56 3.12 EXTERN C ZUM ABSCHALTEN DER NAMENSZERSTUECKELUNG.................................. 57 4. GRUNDSAETZLICHE REGELN BEIM PROGRAMMIEREN ...................................... 58 4.1 INCLUDE-WAECHTER VERWENDEN............................................................................. 58 4.2 KOMMENTAR // DEM KOMMENTAR /* / VORZIEHEN............................................... 58 VII 4.3 OPTIMIERE DIE LAUFZEIT IMMER GLEICH MIT ......................................................... 58 4.3.1 OBJEKTE ERST DORT DEFINIEREN, WO SIE GEBRAUCHT WERDEN ......................... 58 4.3.2 ZUWEISUNG AN EIN OBJEKT MIT DER KONSTRUKTION VERBINDEN.................... 59 4.3.3 RETURN, BREAK UND CONTINUE MIT GESCHICK EINSETZEN ............................... 60 4.4 LAUFVARIABLE IM SCHLEIFENKOPF DEFINIEREN........................................................ 64 4.5 DER STACK IST IMMER DEM HEAP (NEW/DELETE) VORZUZIEHEN ............................... 64 4.6 PROTECTED NUR BEI BASISKLASSEN.......................................................................... 65 4.7 KEINE FEHLER BEIM MISCHEN VON C- UND C++-CODE MACHEN ........................... 65 4.8 UNGARISCHE NOTATION VERWENDEN ...................................................................... 66 4.9 EINGEBAUTE DATENTYPEN NIE HINTER TYPEDEF VERSTECKEN ..................................... 67 4.10 IMPLIZITE TYPUMWANDLUNG GGF. ABSCHALTEN .................................................... 68 4.11 INLINE NUR BEI SEHR EINFACHEN NICHT-VIRTUELLEN FUNKTIONEN.............................. 70 4.11.1 ALLGEMEINES ........................................................................................ 70 4.11.2 WIDERSPRUCH VIRTUAL UND INLINE : VIRTUAL DOMINIERT INLINE................. 71 4.11.3 BASISKLASSE: VIRTUELLER DESTRUKTOR ALS LEERE INLINE-FUNKTION .............. 72 4.12 FALSCHE BENUTZUNG EINER KLASSE AUSSCHLIESSEN ............................................... 72 4.12.1 KOPIE EINES OBJEKTES VERBIETEN .......................................................... 72 4.12.2 KONSTRUKTION EINES OBJEKTES VERBIETEN ............................................... 72 4.13 LAUFZEITSCHALTER IMMER COMPILER-SCHALTERN VORZIEHEN.................................. 73 4.14 SHORT STATT BOOL ALS RETURN-WERT BEI INTERFACE-METHODEN ................................ 74 5. STRINGS ....................................................................................................... 76 5.1 ASCII-TABELLE .................................................................................................. 76 5.2 STRING DER STL................................................................................................... 78 5.2.1 ALLGEMEINES ............................................................................................ 78 5.2.2 STRING FORMATIEREN MIT HILFE VON SPRINTF() .............................................. 80 5.2.3 TEIL-STRINGS ERSETZEN MIT STRING::REPLACE() UND STRING::FIND().................. 81 5.2.4 ZEICHEN LOESCHEN MIT STRING::ERASE() UND EINFUEGEN MIT STRING::INSERT() .... 81 5.2.5 UMWANDLUNG IN ZAHLEN MIT STRTOL() UND DER METHODE STRING::C_STR():.... 82 5.2.6 TEIL EINES ANDEREN STRINGS ANHAENGEN MIT STRING::APPEND() ..................... 82 5.2.7 KONFIGURATIONSDATEIEN PARSEN MIT STRING::COMPARE() UND STRING::COPY() 83 5.2.8 WORTE SORTIEREN MIT SET .............................................................. 86 5.2.9 STRINGS ZUSCHNEIDEN MIT STRING::REPLACE() UND STRING::RESIZE() ................ 87 5.3 STRING STREAMS DER STL...................................................................................... 87 5.3.1 ALLGEMEINES ............................................................................................ 87 5.3.2 TEXT MIT ISTRINGSTREAM NACH ENTHALTENEN WORTEN PARSEN ........................ 88 6. ZEITERMITTLUNG .......................................................................................... 89 6.1 WELTWEIT EINDEUTIGER TIMESTAMP (GMT), JAHR-2038....................................... 89 6.2 AUTOMATISCHE LOKALISIERUNG DER ZEITDARSTELLUNG (STRFTIME) ............................. 90 7. KONSTANTES ................................................................................................ 93 7.1 CONST-ZEIGER (C-FUNKTIONEN)............................................................................ 93 7.2 CONST-REFERENZEN (C++-FUNKTIONEN) ............................................................... 94 7.2.1 ALLGEMEINES ............................................................................................ 94 7.2.2 STL-CONTAINER ALS CONST-REFERENZEN VERLANGEN CONST_ITERATOR.............. 94 7.3 READ-ONLY-MEMBER-FUNKTIONEN ...................................................................... 96 7.3.1 ALLGEMEINES ............................................................................................ 96 7.3.2 MUTABLE-MEMBER ALS INTERNE MERKER (CACHE-INDEX) VERWENDEN............ 96 7.3.3 ZEIGER BEI READ-ONLY-MEMBER-FUNKTION BESONDERS BEACHTEN............... 97 VIII 7.4 CONST-RETURN-WERT.............................................................................................. 98 7.5 CONST STATT #DEFINE VERWENDEN........................................................................... 99 7.5.1 GLOBALE KONSTANTEN................................................................................. 99 7.5.2 LOKALE KONSTANTEN EINER KLASSE ........................................................... 100 7.6 CONST-INLINE-TEMPLATE STATT MAKRO (#DEFINE) VERWENDEN ........................... 101 8. GLOBALES (STATIC-MEMBER)...................................................................... 103 8.1 STATIC-MEMBER................................................................................................. 103 8.1.1 ALLGEMEINES .......................................................................................... 103 8.1.2 ZUGRIFF, OHNE EIN OBJEKT ZU INSTANZIIEREN ............................................. 103 8.2 VORSICHT BEI STATIC-VARIABLEN IN NICHT-STATISCHEN METHODEN .......................... 104 8.3 STATIC-VARIABLE IN STATIC-METHODE STATT GLOBALER VARIABLE............................... 105 8.4 LOKALE STATISCHE ARRAYS DURCH MAIN-THREAD INSTANZIIEREN............................. 108 8.5 GLOBALE FUNKTIONEN: NUTZE VIRTUELLE ARGUMENT-METHODEN ........................... 113 9. REFERENZ STATT ZEIGER (ZEIGER FUER C-INTERFACE) ................................... 114 10. FUNKTIONEN, ARGUMENTE UND RETURN-WERTE ........................................ 116 10.1 ARGUMENTE SOLLTEN IMMER REFERENZEN SEIN .................................................. 116 10.1.1 CONST-REFERENZ STATT WERT-UEBERGABE (SLICING-PROBLEM)................... 116 10.1.2 REFERENZ STATT ZEIGER ......................................................................... 117 10.2 ARGUMENTE: DEFAULT-PARAMETER VS. UEBERLADENE FUNKTION............................. 118 10.3 UEBERLADEN INNERHALB EINER KLASSE VS. UEBER KLASSE HINWEG........................... 119 10.3.1 ALLGEMEINES ...................................................................................... 119 10.3.2 NIE ZEIGER-ARGUMENT MIT WERT-ARGUMENT UEBERLADEN ...................... 120 10.4 RETURN: REFERENZ AUF THIS VS. WERTRUECKGABE................................................ 120 10.4.1 LOKAL ERZEUGTES OBJEKT ZURUECKLIEFERN: RUECKGABE EINES WERTES ....... 120 10.4.2 OBJEKT DER METHODE ZURUECKLIEFERN: REFERENZ AUF THIS..................... 121 10.4.3 KEINE ZEIGER/REFERENZEN AUF PRIVATE-DATEN ZURUECKLIEFERN............... 121 10.5 RETURN-WERT NIE AN REFERENZIERENDES ARGUMENT UEBERGEBEN .......................... 123 11. SMART-POINTER................................................................. ........................ 124 11.1 ALLGEMEINES.................................................................................................. 124 11.2 SMART-POINTER FUER DIE SPEICHER-VERWALTUNG................................................. 124 11.2.1 EIGENSCHAFTEN DES SMART-POINTERS FUER DIE SPEICHERVERWALTUNG........ 124 11.2.2 WAS ZU BEACHTEN IST........................................................................... 125 11.2.3 CODE-BEISPIEL.................................................................................... 126 11.2.4 SMART-POINTER IMMER PER REFERENZ AN EINE FUNKTION UEBERGEBEN...... 128 11.2.5 EMPFEHLUNGEN ................................................................................... 128 11.3 SMART-POINTER FUER ANDERE ZWECKE................................................................. 130 12. NEW/DELETE.................................................................... ............................ 131 12.1 ALLGEMEINES ZU NEW...................................................................................... 131 12.2 ALLGEMEINES ZU DELETE................................................................................... 132 12.3 BEISPIEL FUER NEW/DELETE ................................................................................. 133 12.4 ALLGEMEINES ZU NEW[]/DELETE[]...................................................................... 133 12.4.1 NEW[] ................................................................................................. 133 12.4.2 DELETE[] .............................................................................................. 134 12.5 MIT HEAP-SPEICHER ARBEITEN.......................................................................... 134 IX 12.6 HEAP-SPEICHER ALS SHARED MEMORY .............................................................. 135 12.7 NEW/DELETE STATT MALLOC/FREE.......................................................................... 136 12.8 ZUSAMMENSPIEL VON ALLOKIERUNG UND FREIGABE ........................................... 138 12.9 EIGENER NEW-HANDLER STATT OUT-OF-MEMORY-EXCEPTION............................... 140 12.10 HEAP-SPEICHERUNG ERZWINGEN/VERBIETEN..................................................... 141 12.10.1 HEAP-SPEICHERUNG ERZWINGEN (PROTECTED-DESTRUKTOR) .................. 141 12.10.2 HEAP-SPEICHERUNG VERBIETEN (PRIVATE OPERATOR NEW) .................... 142 13. STATISCHE, HEAP- UND STACK-OBJEKTE .................................................... 144 13.1 DIE 3 SPEICHER-ARTEN.................................................................................... 144 13.2 STATISCHE OBJEKTE (MYCLASS::METHOD())....................................................... 146 13.3 HEAP-OBJEKTE (POBJ- METHOD()) ................................................................. 146 13.4 STACK-OBJEKTE (OBJ.METHOD())...................................................................... 147 14. PROGRAMMIERUNG EINER KLASSE.............................................................. 147 14.1 ALLGEMEINES.................................................................................................. 147 14.1.1 FRAGEN, DIE BEIM ENTWURF EINER KLASSE BEANTWORTET WERDEN SOLLTEN 147 14.1.2 DIE WESENTLICHEN METHODEN EINER KLASSE SIND ZU IMPLEMENTIEREN .. 148 14.1.3 DURCH DEN COMPILER AUTOMATISCH GENERIERTE METHODEN BEACHTEN.... 149 14.1.4 INLINE-FUNKTIONEN GGF. HINTER DIE DEKLARATION SCHREIBEN .................. 150 14.1.5 NIE PUBLIC-DATEN VERWENDEN ............................................................ 151 14.1.6 MEHRDEUTIGKEITEN (AMBIGIOUS) ERKENNEN .......................................... 152 14.2 DER KONSTRUKTOR............................................................................................ 154 14.2.1 KEIN NEW IM KONSTRUKTOR / INITIALISIERUNGSLISTEN FUER MEMBER.......... 154 14.2.2 KEINE VIRTUELLEN METHODEN IM KONSTRUKTOR AUFRUFEN ....................... 157 14.2.3 ARRAYS MIT MEMSET() INITIALISIEREN .................................................... 157 14.3 DER DESTRUKTOR .............................................................................................. 157 14.3.1 GENERALISIERUNG ( IS-A ): BASISKLASSE SOLL VIRTUELLEN DESTRUKTOR HABEN.............................................................. 157 14.4 ZUWEISUNG PER OPERATOR=() ........................................................................... 158 14.4.1 KEINE ZUWEISUNG AN SICH SELBST........................................................ 158 14.4.2 REFERENZ AUF THIS ZURUECKLIEFERN....................................................... 159 14.4.3 ALLE MEMBER-VARIABLEN BELEGEN....................................................... 159 14.5 INDIZIERTER ZUGRIFF PER OPERATOR[]() ............................................................... 160 14.6 VIRTUELLE CLONE()-FUNKTION: HEAP-KOPIE UEBER PBASE .................................. 161 14.7 OBJEKTANZAHL UEBER PRIVATE-KONSTRUKTOR KONTROLLIEREN .................................. 163 14.7.1 OBJEKTE UEBER EINE FRIEND-KLASSE (OBJEKT-MANAGER) ERZEUGEN .......... 163 14.7.2 OBJEKTE UEBER EINE STATISCHE CREATE()-FUNKTION ERZEUGEN .................. 164 14.7.3 GENAU 1 OBJEKT ERZEUGEN (CODE UND/ODER TABELLE) ......................... 165 14.8 KLASSEN NEU VERPACKEN MITTELS WRAPPER-KLASSE .......................................... 166 15. RICHTIGES VERERBUNGS-KONZEPT............................................................. 167 15.1 ALLGEMEINES.................................................................................................. 167 15.1.1 NIE VON (NICHT-ABSTRAKTEN) KLASSEN OHNE VIRTUELLEN DESTRUKTOR ERBEN .............................................................. 167 15.1.2 NIE DEN COPY-KONSTRUKTOR-AUFRUF DER BASISKLASSE VERGESSEN ......... 168 15.1.3 STATISCHER/DYNAMISCHER TYP UND STATISCHE/DYNAMISCHE BINDUNG..... 169 15.1.4 NIE DIE DEFAULT-PARAMETER VIRTUELLER FUNKTIONEN UEBERSCHREIBEN ...... 170 X 15.1.5 PUBLIC-, PROTECTED- UND PRIVATE-VERERBUNG GEZIELT VERWENDEN ......... 170 15.1.6 REIN VIRTUELL / VIRTUELL / NICHT-VIRTUELL................................................ 174 15.1.7 REIN VIRTUELLE METHODEN, WENN KEINE GENERALISIERTE IMPLEM. MOEGLICH............................................................................................. 174 15.2 SPEZIALISIERUNG DURCH PUBLIC-VERERBUNG ( IS A ).......................................... 175 15.3 CODE-SHARING DURCH PRIVATE-VERERBUNG ( CONTAINS )................................... 177 15.4 COMPOSITION STATT MULTIPLE INHERITANCE......................................................... 180 15.5 SCHNITTSTELLEN (ABSTRACTMIXINBASECLASS) PUBLIC DAZUERBEN ........................ 181 15.6 ABSTRAKTE BASISKLASSE VS. TEMPLATE ............................................................. 183 15.7 VERKNUEPFUNG KONKRETER KLASSEN: ABSTRAKTE BASISKLASSE............................... 184 15.8 ERBEN AUS MEHREREN BASISKLASSEN VERMEIDEN............................................... 185 15.8.1 EXPLIZITER ZUGRIFF (ODER USING).......................................................... 185 15.8.2 VIRTUELLE VERERBUNG (DIAMANT-STRUKTUR) .......................................... 185 15.9 ZUWEISUNGEN NUR ZWISCHEN GLEICHEN CHILD-TYPEN ZULASSEN........................ 187 16. NUTZER EINER KLASSE VON AENDERUNGEN ENTKOPPELN.............................. 189 16.1 ALLGEMEINES.................................................................................................. 189 16.2 HEADER-DATEIEN: FORWARD-DEKLARATION STATT #INCLUDE .................................. 189 16.3 DELEGATION BZW. AGGREGATION....................................................................... 190 16.4 OBJEKT-FACTORY-KLASSE UND PROTOKOLL-KLASSE............................................... 192 17. CODE KAPSELN........................................................................................... 194 17.1 BELIEBIG VIELE KOPIEN ERLAUBT: FUNKTIONS-OBJ. (OPERATOR())......................... 194 17.2 NUR 1 KOPIE ERLAUBT: STATISCHE OBJ. (MYCLASS::METHOD()) .......................... 194 18. OPERATOREN.................................................................... .......................... 195 18.1 DEFINITION VON OPERATOREN............................................................................ 195 18.2 BINAERE OPERATOREN EFFEKTIV IMPLEMENTIEREN................................................. 196 18.3 UNAERE OPERATOREN BEVORZUGT VERWENDEN...................................................... 197 18.4 KOMMUTATIVITAET: GLOBALE BIN. OPERATOREN IMPLEMENTIEREN.......................... 197 18.5 OPERATOR-VORRANG (PRECEDENCE) ................................................................... 199 18.6 PRAEFIX- UND POSTFIX-OPERATOR ........................................................................ 200 18.6.1 ALLGEMEINES ...................................................................................... 200 18.6.2 WARTUNGSFREUNDLICHKEIT ERHOEHEN DURCH ++(THIS) IM POSTFIX-OPERATOR.......................................................................... 202 18.6.3 PRAEFIX(++OBJ) IST POSTFIX(OBJ++) VORZUZIEHEN................................. 202 18.7 DER KOMMA-OPERATOR , ................................................................................ 203 19. DATENTYPEN UND CASTING........................................................................ 205 19.1 DATENTYPEN.................................................................................................... 205 19.2 POLYMORPHISMUS: VFPTR UND VFTABLE .............................................................. 206 19.3 RTTI (TYPE_INFO) UND TYPEID BEI POLYMORPHEN OBJEKTEN ............................ 208 19.4 DYNAMIC_CAST: SICHERER CAST VON ZEIGERN ODER REFERENZEN.......................... 210 19.4.1 ALLGEMEINES ...................................................................................... 210 19.4.2 DYNAMIC_CAST ZUR ARGUMENTPRUEFUNG BEI BASISKLASSEN-ZEIGER/REFERENZ.................................................... 212 19.5 CONST_CAST...................................................................................................... 214 19.6 REINTERPRET_CAST (!NICHT PORTABEL!) UND FUNKTIONS-VEKTOREN......................... 214 19.7 STL: MIN- UND MAX-WERTE ZU EINEM DATENTYP ........................................... 215 XI 20. IN BIBLIOTHEKEN EXCEPTIONS WERFEN ...................................................... 216 20.1 ALLGEMEINES.................................................................................................. 216 20.2 EXCEPTIONS PER REFERENZ FANGEN................................................................... 219 20.3 KOPIEN BEIM WEITERWERFEN VERMEIDEN ........................................................ 220 20.4 BEISPIEL FUER EXCEPTION-HANDLING.................................................................. 221 20.5 EXCEPTION-SPEZIFIKATION ............................................................................... 221 20.5.1 ALLGEMEINES ..................................................................................... 221 20.5.2 SPEZIFIKATIONSWIDRIGE EXCEPTIONS ABFANGEN: SET_UNEXPECTED ......... 222 20.5.3 COMPILERUNABHAENGIGES VORGEHEN.................................................... 223 21. DIE STL (STANDARD TEMPLATE LIBRARY)................................................ 224 21.1 ALLGEMEINES.................................................................................................. 224 21.2 NUTZUNG DER STL VON STLPORT..................................................................... 228 21.2.1 ALLGEMEINES ..................................................................................... 228 21.2.2 STLPORT MIT GNU UNTER LINUX ........................................................ 228 21.2.3 STLPORT MIT VISUAL C++ UNTER WINDOWS ........................................ 230 21.3 STL-HEADER-DATEIEN .................................................................................... 231 21.3.1 AUFBAU: DIE ENDUNG .H FEHLT......................................................... 231 21.3.2 NUTZUNG: USING NAMESPACE STD ...................................................... 231 21.4 WICHTIGE STL-MEMBER-VARIABLEN UND METHODEN ....................................... 232 21.5 GENERIERUNG VON SEQUENZEN UEBER STL-ALGORITHMEN................................... 237 21.5.1 BACK_INSERTER() ................................................................................. 237 21.5.2 SCHNITTMENGE (SET_INTERSECTION)....................................................... 237 21.5.3 SCHNITTMENGE AUSSCHLIESSEN (SET_SYMMETRIC_DIFFERENCE)................. 238 21.5.4 SEQUENZ AUSSCHLIESSEN (SET_DIFFERENCE) ............................................ 238 21.5.5 VEREINIGUNGSMENGE BILDEN (SET_UNION) ........................................... 239 21.5.6 LISTE AN EINE ANDERE LISTE ANHAENGEN (LIST::INSERT) ........................... 239 21.6 WICHTIGE REGELN ........................................................................................... 240 21.6.1 EINBINDEN DER STL........................................................................... 240 21.6.2 DIE BENOETIGTEN OPERATOREN IMPLEMENTIEREN..................................... 241 21.6.3 ITERATOR: ++IT STATT IT++ BENUTZEN ...................................................... 242 21.6.4 LOESCHEN NACH FIND(): IMMER UEBER ITERATOR (IT) STATT UEBER DEN WERT (IT) ................................................................... 243 21.6.5 MAP: NIE INDIZIERTEN ZUGRIFF [ ] NACH FIND() DURCHFUEHREN ................ 245 21.7 BEISPIELE FUER DIE VERWENDUNG DER CONTAINER ............................................... 247 21.7.1 LIST: AUFLISTUNG VON OBJEKTEN MIT MOEGLICHEN MEHRFACHVORKOMMNISSEN ................................................................ 247 21.7.2 SET: AUFSTEIGEND SORTIERTE MENGE VON OBJEKTEN (UNIQUE) ................ 249 21.7.3 MAP: ZUORDNUNG VON OBJEKTEN ZU EINDEUTIGEN HANDLES.................. 250 21.7.4 MAP: MEHRDIMENSIONALER SCHLUESSEL ................................................. 252 21.7.5 VECTOR: SCHNELLER INDIZIERTER ZUGRIFF ................................................ 254 21.7.6 PAIR UND MAKE_PAIR(): WERTEPAARE ABSPEICHERN ............................... 255 21.8 HASH_MAP...................................................................................................... 256 21.8.1 HASH_MAP FUER NUTZER VON VISUAL C++ ............................................. 256 21.8.2 PRINZIP VON HASH_MAP...................................................................... 256 21.8.3 NUTZUNG VON HASH_MAP DER STL ..................................................... 258 21.9 LOKALISIERUNG MIT DER STL (STREAMS UND LOCALES) ........................................ 262 XII XIII 22. ARTEN VON TEMPLATES ............................................................................. 267 22.1 CLASS-TEMPLATE ............................................................................................. 267 22.2 FUNCTION-TEMPLATE........................................................................................ 268 22.2.1 GLOBAL FUNCTION TEMPLATE ............................................................... 268 22.2.2 MEMBER FUNCTION TEMPLATE............................................................. 268 22.3 EXPLIZITE INSTANZIIERUNG VON TEMPLATES ....................................................... 269 23. PROXY-KLASSEN................................................................. ........................ 270 23.1 ALLGEMEINES .................................................................................................. 270 23.2 SCHREIBEN/LESEN BEIM INDIZIERTEN ZUGRIFF UNTERSCHEIDEN............................. 271 24. DATENBANK-ZUGRIFF............................................................. .................... 274 24.1 ZUGRIFF AUF OBJEKTORIENTIERTE DATENBANKEN................................................... 274 24.2 ZUGRIFF AUF RELATIONALE DATENBANKEN ............................................................ 275 24.3 ZUGRIFF AUF HIERARCHISCHE DATENBANKEN ........................................................ 283 25. AKTION NACH KOLLISION UEBER OBJEKTTYP STEUERN................................... 284 26. 80/20-REGEL UND PERFORMANCE-OPTIMIERUNG....................................... 289 26.1 ALLGEMEINES .................................................................................................. 289 26.2 ZEIT-OPTIMIERUNGEN ...................................................................................... 290 26.2.1 RETURN SO FRUEH WIE MOEGLICH............................................................... 290 26.2.2 PRAEFIX-OPERATOR STATT POSTFIX-OPERATOR............................................. 290 26.2.3 UNAERE OPERATOREN DEN BINAEREN OPERATOREN VORZIEHEN ..................... 290 26.2.4 KEINE KONSTRUKTION/DESTRUKTION IN SCHLEIFEN.................................. 291 26.2.5 HASH_MAP STATT MAP, FALLS KEINE SORTIERUNG BENOETIGT WIRD............... 291 26.2.6 LOKALER CACHE UM BERECHNUNGEN/DATENERMITTLUNGEN ZU SPAREN..... 291 26.2.7 LOESCHEN NACH FIND() IMMER DIREKT UEBER DEN ITERATOR........................ 293 26.2.8 MAP: NIE INDIZIERTEN ZUGRIFF [ ] NACH FIND() DURCHFUEHREN ................. 294 26.2.9 UNSICHTBARE TEMPORAERE OBJEKTE VERMEIDEN ..................................... 295 26.2.10 BERECHNUNGEN ERST DANN, WENN DAS ERGEBNIS GEBRAUCHT WIRD........ 298 26.2.11 DATENERMITTLUNG ERST DANN, WENN DIE DATEN GEBRAUCHT WERDEN ..... 298 26.2.12 GROSSE ANZAHL KLEINER OBJEKTE BLOCKWEISE LESEN (PREFETCHING)..... 298 26.2.13 KEIN UNNOETIGES SPEICHERN IN DIE DATENBANK.................................. 299 26.2.14 SQL-SELECT-STATEMENTS EFFEKTIV AUFBAUEN: DB-SERVER FILTERN LASSEN................................................................. 299 26.3 SPEICHER-OPTIMIERUNGEN............................................................................... 300 26.3.1 SHARING VON CODE UND/ODER TABELLEN MITTELS STATISCHEM OBJEKT..... 300 26.3.2 SHARING VON CODE UND/ODER TABELLEN MITTELS HEAP-OBJEKT............. 300 26.3.3 NACH KOPIE DIE DATEN BIS ZUM SCHREIBZUGRIFF SHAREN (COPY-ON-WRITE).............................................................................. 302 26.3.4 OBJECT-POOLING ................................................................................. 305 INDEX ................................................................................................................. 309
any_adam_object	1
author	Thömmes, Peter
author_facet	Thömmes, Peter
author_role	aut
author_sort	Thömmes, Peter
author_variant	p t pt
building	Verbundindex
bvnumber	BV019381674
classification_rvk	ST 250
ctrlnum	(OCoLC)76428558 (DE-599)BVBBV019381674
discipline	Informatik
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>01333nam a2200385 c 4500</leader><controlfield tag="001">BV019381674</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20050120 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">040902s2004 gw d\|\|\| \|\|\|\| 00\|\|\| ger d</controlfield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">967073081</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3540010580</subfield><subfield code="c">Pp. : EUR 39.95</subfield><subfield code="9">3-540-01058-0</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)76428558</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)BVBBV019381674</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="044" ind1=" " ind2=" "><subfield code="a">gw</subfield><subfield code="c">DE</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-526</subfield><subfield code="a">DE-11</subfield><subfield code="a">DE-2070s</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="100" ind1="1" ind2=" "><subfield code="a">Thömmes, Peter</subfield><subfield code="e">Verfasser</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Notizen zu C++</subfield><subfield code="c">Peter Thömmes</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Berlin [u.a.]</subfield><subfield code="b">Springer</subfield><subfield code="c">2004</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XIII, 312 S.</subfield><subfield code="b">graph. Darst.</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">Xpert.press</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">STL</subfield><subfield code="0">(DE-588)4411326-2</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="689" ind1="0" 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="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="1" ind2="0"><subfield code="a">STL</subfield><subfield code="0">(DE-588)4411326-2</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">SWB 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=012844713&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-012844713</subfield></datafield></record></collection>
id	DE-604.BV019381674
illustrated	Illustrated
indexdate	2024-07-09T19:58:59Z
institution	BVB
isbn	3540010580
language	German
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-012844713
oclc_num	76428558
open_access_boolean
owner	DE-526 DE-11 DE-2070s
owner_facet	DE-526 DE-11 DE-2070s
physical	XIII, 312 S. graph. Darst.
publishDate	2004
publishDateSearch	2004
publishDateSort	2004
publisher	Springer
record_format	marc
series2	Xpert.press
spelling	Thömmes, Peter Verfasser aut Notizen zu C++ Peter Thömmes Berlin [u.a.] Springer 2004 XIII, 312 S. graph. Darst. txt rdacontent n rdamedia nc rdacarrier Xpert.press C++ (DE-588)4193909-8 gnd rswk-swf STL (DE-588)4411326-2 gnd rswk-swf C++ (DE-588)4193909-8 s DE-604 STL (DE-588)4411326-2 s SWB Datenaustausch application/pdf http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=012844713&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA Inhaltsverzeichnis
spellingShingle	Thömmes, Peter Notizen zu C++ C++ (DE-588)4193909-8 gnd STL (DE-588)4411326-2 gnd
subject_GND	(DE-588)4193909-8 (DE-588)4411326-2
title	Notizen zu C++
title_auth	Notizen zu C++
title_exact_search	Notizen zu C++
title_full	Notizen zu C++ Peter Thömmes
title_fullStr	Notizen zu C++ Peter Thömmes
title_full_unstemmed	Notizen zu C++ Peter Thömmes
title_short	Notizen zu C++
title_sort	notizen zu c
topic	C++ (DE-588)4193909-8 gnd STL (DE-588)4411326-2 gnd
topic_facet	C++ STL
url	http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=012844713&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT thommespeter notizenzuc

Verfügbarkeit

Es ist kein Print-Exemplar vorhanden.

Fernleihe Bestellen Achtung: Nicht im THWS-Bestand! Inhaltsverzeichnis

MARC

Datensatz im Suchindex

Es ist kein Print-Exemplar vorhanden.

Ähnliche Einträge