Forschung mit modernem C++: C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer
Gespeichert in:
| 1. Verfasser: | |
|---|---|
| Format: | Buch |
| Sprache: | German |
| Veröffentlicht: |
München
Hanser
[2019]
|
| Schlagworte: | |
| Online-Zugang: | Inhaltsverzeichnis |
| Beschreibung: | XXIV, 504 Seiten Diagramme 24 cm |
| ISBN: | 9783446458468 3446458468 |
Internformat
MARC
| LEADER | 00000nam a2200000 c 4500 | ||
|---|---|---|---|
| 001 | BV045400998 | ||
| 003 | DE-604 | ||
| 005 | 20210326 | ||
| 007 | t | ||
| 008 | 190115s2019 gw |||| |||| 00||| ger d | ||
| 015 | |a 18,N51 |2 dnb | ||
| 016 | 7 | |a 1173270469 |2 DE-101 | |
| 020 | |a 9783446458468 |c kart. : EUR 44.90 (DE) |9 978-3-446-45846-8 | ||
| 020 | |a 3446458468 |9 3-446-45846-8 | ||
| 024 | 3 | |a 9783446458468 | |
| 028 | 5 | 2 | |a Bestellnummer: 553/45846 |
| 035 | |a (OCoLC)1079440184 | ||
| 035 | |a (DE-599)DNB1173270469 | ||
| 040 | |a DE-604 |b ger |e rda | ||
| 041 | 0 | |a ger | |
| 044 | |a gw |c XA-DE-BY | ||
| 049 | |a DE-M347 |a DE-860 |a DE-92 |a DE-1050 |a DE-706 |a DE-210 |a DE-20 |a DE-91G |a DE-83 |a DE-Aug4 |a DE-739 |a DE-12 |a DE-634 |a DE-1046 |a DE-11 |a DE-1028 | ||
| 084 | |a ST 250 |0 (DE-625)143626: |2 rvk | ||
| 084 | |a 004 |2 sdnb | ||
| 084 | |a DAT 358f |2 stub | ||
| 100 | 1 | |a Gottschling, Peter |d 1967- |e Verfasser |0 (DE-588)124235832 |4 aut | |
| 245 | 1 | 0 | |a Forschung mit modernem C++ |b C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer |c Peter Gottschling |
| 264 | 1 | |a München |b Hanser |c [2019] | |
| 264 | 4 | |c © 2019 | |
| 300 | |a XXIV, 504 Seiten |b Diagramme |c 24 cm | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b n |2 rdamedia | ||
| 338 | |b nc |2 rdacarrier | ||
| 650 | 0 | 7 | |a C++17 |0 (DE-588)1147325278 |2 gnd |9 rswk-swf |
| 650 | 0 | 7 | |a C++ |0 (DE-588)4193909-8 |2 gnd |9 rswk-swf |
| 650 | 0 | 7 | |a Programmierung |0 (DE-588)4076370-5 |2 gnd |9 rswk-swf |
| 650 | 0 | 7 | |a Wissenschaft |0 (DE-588)4066562-8 |2 gnd |9 rswk-swf |
| 650 | 0 | 7 | |a Forschung |0 (DE-588)4017894-8 |2 gnd |9 rswk-swf |
| 653 | |a Mixed media product | ||
| 689 | 0 | 0 | |a C++ |0 (DE-588)4193909-8 |D s |
| 689 | 0 | 1 | |a Wissenschaft |0 (DE-588)4066562-8 |D s |
| 689 | 0 | 2 | |a Forschung |0 (DE-588)4017894-8 |D s |
| 689 | 0 | |5 DE-604 | |
| 689 | 1 | 0 | |a C++17 |0 (DE-588)1147325278 |D s |
| 689 | 1 | 1 | |a Programmierung |0 (DE-588)4076370-5 |D s |
| 689 | 1 | 2 | |a Forschung |0 (DE-588)4017894-8 |D s |
| 689 | 1 | |5 DE-604 | |
| 776 | 0 | 8 | |i Erscheint auch als |n Online-Ausgabe |z 978-3-446-45981-6 |
| 856 | 4 | 2 | |m Digitalisierung UB Passau - ADAM Catalogue Enrichment |q application/pdf |u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=030787088&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |3 Inhaltsverzeichnis |
| 999 | |a oai:aleph.bib-bvb.de:BVB01-030787088 | ||
Datensatz im Suchindex
| _version_ | 1804179269506564096 |
|---|---|
| adam_text | Inhalt Ц Grundlagen............................... 1 1.1 Unser erstes Programm...................... 1 1.2 Variablen............................................. 3 1.2.1 Fundamentale Typ en.............. 4 1.2.2 Characters und Strings........... 5 1.2.3 Variablendeklarieren.............. 6 1.2.4 Konstanten.............................. 6 1.2.5 Literale..................................... 7 1.2.6 Werterhaltende Initialisierung 9 1.2.7 Gültigkeitsbereiche................ 10 1.3 Operatoren......................................... 12 1.3.1 Arithmetische Operatoren..... 13 1.3.2 Boolesche Operatoren............ 15 1.3.3 Bitweise Operatoren............... 16 1.3.4 Zuweisung................................ 17 1.3.5 Programmablauf..................... 18 1.3.6 Speicherverwaltung................. 19 1.3.7 Zugriffsoperatoren.................. 19 1.3.8 Typbehandlung........................ 19 1.3.9 Fehlerbehandlung................... 20 1.3.10 Überladung............................. 20 1.3.11 Operatorprioritäten................. 20 1.3.12 Vermeiden Sie Seiteneffekte!... 21 1.4 Ausdrücke und Anweisungen............ 23 1.4.1 Ausdrücke................................ 23 1.4.2 Anweisungen.......................... 24 1.4.3 Verzweigung............................ 24 1.4.4 Schleifen................................... 27 1.4.5 goto......................................... 30 1.5 Funktionen......................................... 31 1.5.1 Argumente.............................. 31
XVI Inhalt 1.5.2 Rückgabe der Ergebnisse............................................................................ 33 1.5.3 Inlining........................................................................................................ 34 1.5.4 Überladen.................................................................................................... 34 1.5.5 Die ma in-Funktion...................................................................................... 36 1.6 Fehlerbehandlung.................................................................................................. 37 1.6.1 Zusicherungen............................................................................................. 37 1.6.2 Ausnahmen................................................................................................. 39 1.6.3 Statische Zusicherungen............................................................................ 43 1.7 I/O........................................................................................................................... 44 1.7.1 Standard-Ausgabe.......................................... 44 1.7.2 Standard-Eingabe....................................................................................... 45 1.7.3 Ein-/Ausgabe mit Dateien......................................................................... 45 1.7.4 Generisches Stream-Konzept................................................. 46 1.7.5 Formatierung.............................................................................................. 47 1.7.6
I/O-Fehlerbehandeln................................................................................ 48 1.7.7 File-System.................................................................................................. 51 1.8 Arrays, Zeiger und Referenzen............................................................................... 52 1.8.1 Arrays.......................................................................................................... 52 1.8.2 Zeiger.......................................................................................................... 54 1.8.3 Intelligente Zeiger....................................................................................... 57 1.8.4 Referenzen.................................................................................................. 60 1.8.5 Vergleich zwischen Zeigern und Referenzen............................................ 60 1.8.6 Nicht auf abgelaufene Daten verweisen!................................................... 61 1.8.7 Containers for Arrays.................................................................................. 62 1.9 Strukturierung von Software-Projekten................................................................ 64 1.9.1 Kommentare............................................................................................... 64 1.9.2 Präprozessor-Direktiven............................................................................ 66 1.10 Aufgaben................................................................................................................. 70 1.10.1
Verengung................................................................................................... 70 1.10.2 Literale.................................................................................... 70 1.10.3 Operatoren.................................................................................................. 70 1.10.4 Verzweigung............................................................................................... 70 1.10.5 Schleifen...................................................................................................... 70 1.10.6 1/0................................................................................................................ 71 1.10.7 Arrays und Zeiger........................................................................................ 71 1.10.8 Funktionen.................................................................................................. 71
Inhalt XVII Q Klassen............................................................................................. 72 2.1 Universell programmieren, nicht detailversessen............... 72 2.2 Member................................................................................................................... 74 2.2.1 Mitgliedervariablen.................................................................................... 75 2.2.2 Zugriffsrechte....................................................... 75 2.2.3 Zugriffsoperatoren..................................................................................... 78 2.2.4 Der static-Deklarator für Klassen........................................................... 78 2.2.5 Member-Funktionen................................................................................. 79 2.3 Konstruktoren und Zuweisungen.................... 80 2.3.1 Konstruktoren................................. 80 2.3.2 Zuweisungen............................................................................................... 90 2.3.3 Initialisierungslisten................................................................................... 91 2.3.4 Einheidiche Initialisierung......................................................................... 93 2.3.5 Move-Semantik................................................ 95 2.3.6 Objekte aus Literalen konstruieren........................................................ 2.4 Destruktoren.......................................................................................................... 101 103 2.4.1
Implementierungsregein.................................................... 104 2.4.2 Richtiger Umgang mit Ressourcen.............................................. 104 2.5 Zusammenfassung der Methodengenerierung..................... 110 2.6 Zugriff auf Mitgliedervariablen............................................................................. 111 2.6.1 Zugriffsfunktionen..................................................................................... 111 2.6.2 Index-Operator....................... 112 2.6.3 Konstante Mitgliederfunktionen...................................................... 113 2.6.4 Referenz-qualifizierte Mitglieder.................................................... 115 2.7 Design von Operatorüberladung............................... 116 2.7.1 Seien Sie konsistent!................................................................................... 116 2.7.2 Die Priorität respektieren..................................................... 117 2.7.3 Methoden oder freie Funktionen.............................................................. 118 2.8 Aufgaben................................................................................................................. 121 2.8.1 Polynomial................................................................................................ 121 2.8.2 Rational....................................................................................................... 121 2.8.3 Move-Zuweisung........................................................................................ 122 2.8.4
Initialisierungsliste..................................................................................... 122 2.8.5 Ressourcenrettung...................................................................................... 122
XVIII Inhalt Q Generische Programmierung........................................................... 123 3.1 Funktions-Templates............................................................................................. 123 3.1.1 Parametertyp-Deduktion........................................................................... 124 3.1.2 Mit Fehlern in Templates klarkommen................................. 128 3.1.3 Gemischte Typen........................................................................................ 129 3.1.4 Einheitliche Initialisierung......................................................................... 130 3.1.5 Automatischer Rückgabetyp....................................................................... 130 3.2 Namensräume und Funktionssuche..................................................................... 131 3.2.1 Namensräume............................................................................................. 131 3.2.2 Argumentabhängiges Nachschlagen......................................................... 134 3.2.3 Namensraum-Qualifizierung oder ADL..................................................... 138 3.3 Klassen-Templates................................................................................................. 140 3.3.1 Ein Container-Beispiel................. 140 3.3.2 Einheitliche Massen- und Funktionsschnittstellen entwerfen............... 142 3.4 Typ-Deduktion und -Definition............................................................................ 148 3.4.1 Automatische
Variablentypen.................................................................... 148 3.4.2 Typ eines Ausdrucks................................................................................... 148 3.4.3 decltype(auto)........................................................................................... 149 3.4.4 Deduzierte Klassen-Template-Parameter................................................ 151 3.4.5 Mehrere Typen deduzieren........................... 152 3.4.6 Typen definieren........................................................................................ 153 3.5 Etwas Theorie zu Templates: Konzepte................................................................. 155 3.6 Template-Spezialisierung................................................ 156 3.6.1 Spezialisierung einer Klasse für einen Typ................. 156 3.6.2 Funktionen Spezialisieren und Überladen............................................... 158 3.6.3 Partielle Spezialisierung von Klassen................................. 160 3.6.4 Partiell spezialisierte Funktionen.............................................................. 161 3.6.5 Strukturierte Bindung mit Nutzertypen..................................................... 163 3.7 Nicht-Typ-Parameter für Templates..................................................................... 166 3.7.1 Container fester Größe........................................................... 166 3.7.2 Nicht-Typ-Parameter deduzieren.............................................................. 169 3.8
Funktoren................................................................................................................ 169 3.8.1 Funktionsartige Parameter......................................................................... 171 3.8.2 Funktoren zusammensetzen..................................................................... 172 3.8.3 Rekursion..................................................................................................... 174 3.8.4 Generische Reduktion................................................................................ 177 3.9 Lambdas................................................................................................................. 178 3.9.1 Objekte erfassen.......................................................................................... 179
Inhalt 3.9.2 Generische Lambdas................................................................................. XIX 183 3.10 Variablen-Templates.............................................................................................. 183 3.11 Variadische Templates........................................................................................... 3.11.1 Rekursive Funktionen............................................................... 185 185 3.11.2 Direkte Expansion....................................................................................... 187 3.11.3 Indexsequenzen.............................................................................. 188 3.11.4 Faltung......................................................................................................... 190 3.11.5 lypgeneratoren........................................................................................... 191 3.11.6 Wachsende Tests........................................................................................ 191 3.12 Übungen................................................................................................................. 193 3.12.1 String-Darstellung...................................................................................... 193 3.12.2 String-Darstellung von Tupeln.................................................................. 193 3.12.3 Generischer Stack................................................................................... 194 3.12.4 Rationale Zahlen mit Typparameter..........................................................
194 3.12.5 Iterator eines Vektors................................................................................. 194 3.12.6 Ungerader Iterator..................................................................................... 194 3.12.7 Bereich von ungeraden Zahlen.................................................................. 195 3.12.8 Stack von bool........................................................... 195 3.12.9 Stack mit nutzerdefinierter Größe................... 195 3.12.10Deduktion von Nicht-Typ-Template-Argumenten................................... 195 3.12.11 Trapez-Regel............................................................................................... 196 3.12.12 Partielle Spezialisierung mit einer statischen Funktion.......................... 196 3.12.13 Funktor....................................................................................................... 196 3.12.14Lambda...................................................................................................... 196 3.12.15 Implementieren Siemake_unique.............................................................. 197 Q Bibliotheken......................................................................................... 198 4.1 Standard-Template-Library................................................................................... 199 4.1.1 Einführendes Beispiel......................................... 199 4.1.2 Iteratoren.......................................................................... 200 4.1.3
Container..................................................................................................... 205 4.1.4 Algorithmen........................................................... 214 4.1.5 Jenseits von Iteratoren................................................................................ 219 4.1.6 Parallele Berechnung................................................................................. 221 4.2 Numerik.................................................................................................................. 222 4.2.1 Komplexe Zahlen........................................................................................ 222 4.2.2 Zufallszahlengeneratoren.......................................................................... 225 4.2.3 Mathematische Spezialfunktionen........................................................... 234
XX Inhalt 4.3 Meta-Programmierung.......................................................................................... 235 4.3.1 Wertgrenzen.......................................................................... 235 4.3.2 TVpeigenschaften........................................................................................ 237 4.4 Utilities.................................................................. 239 4.4.1 optional...................................................................................................... 239 4.4.2 Ihpel............................................................. 240 4.4.3 variant....................................................................................................... 243 4.4.4 any................................................................................................................ 245 4.4.5 string_view................................................................................................. 246 4.4.6 function...................................................................................................... 247 4.4.7 Referenz-Wrapper....................................................................................... 250 4.5 Die Zeit ist gekommen........................................................................................... 252 4.6 Parallelität.............................................................................................................. 254 4.6.1 Terminologie............................................................................................... 254 4.6.2
Überblick........................................................ 255 4.6.3 Threads........................................................................................................ 255 4.6.4 Rückmeldung an den Aufrufer.............................................. 257 4.6.5 Asynchrone Aufrufe.................................................................................... 258 4.6.6 Asynchroner Gleichungslöser.................................................................... 260 4.6.7 VariadischeMutex-Sperre.......................................................................... 264 4.7 Wissenschaftliche Bibliotheken j enseits des Standards...................................... 266 4.7.1 Andere Arithmetiken.................................................................................. 266 4.7.2 Intervallarithmetik...................................................................................... 267 4.7.3 Lineare Algebra........................................................................................... 267 4.7.4 Gewöhnliche Differentialgleichungen...................................................... 268 4.7.5 Partielle Differentialgleichungen................................................................ 268 4.7.6 Graphenalgorithmen........................................ 4.8 Übungen................................................................................................................. 269 269 4.8.1 Sortierung nach Betrag............................................................................... 269 4.8.2 Suche mit einem Lambda als
Prädikat...................................................... 269 4.8.3 STL-Container............................................................................................. 270 4.8.4 Komplexe Zahlen......................................................................................... 270 4.8.5 Parallele Vektoraddition.............................................................................. 271 4.8.6 Refaktorisierung der parallelen Addition.................................................. 271
Inhalt XXI Q Meta-Programmierung....................................................................... 273 5.1 Lassen Sie den Compiler rechnen......................................................................... 273 5.1.1 Kompilierzeitfunktionen............................................................................ 273 5.1.2 Erweiterte Kompilierzeitfunktionen ........................................................ 275 5.1.3 Primzahlen.................................................................................................. 277 5.1.4 Wie konstant sind unsere Konstanten?......................... 279 5.1.5 Kompilierzeit-Lambdas...................... 280 5.2 Typinformationen.................................................................................................. 281 5.2.1 Typabhängige Funktionsergebnisse.......................................................... 281 5.2.2 Bedingte Ausnahmebehandlung............................................................... 285 5.2.3 Ein Beispiel für eine const-korrekte View................................................ 286 5.2.4 Standard-Typmerkmale.............................................. 293 5.2.5 Domän-spezifische Type-Traits................................................................. 293 5.2.6 Typeigenschaften mit Überladung............... 295 5.2.7 enable_if................................................................................................... 297 5.2.8 Variadische Templates überarbeitet.......................................................... 301 5.3 Expression-
Templates................................................... 304 5.3.1 Einfache Implementierung eines Additionsoperators............................. 304 5.3.2 Eine Klasse für Expression-Templates....................................................... 308 5.3.3 Generische Expression-Templates............................................................ 310 5.4 Compiler-Optimierung mit Meta-Tuning............................................................. 312 5.4.1 Klassisches Abrollen mit fester Größe....................................................... 313 5.4.2 Geschachteltes Abrollen............................................................................. 317 5.4.3 Aufwärmung zum dynamischen Abrollen................................................ 323 5.4.4 Abrollen von Vektorausdrücken................................................................. 324 5.4.5 Tüning von Expression-Templates............................................................. 326 5.4.6 Tuning von Reduktionen............................................................................ 329 5.4.7 Tuning geschachtelter Schleifen................................................ 336 5.4.8 Resümee des Tunings................................................................................. 341 5.5 Turing-Vollständigkeit.......................... 343 5.6 Übungen................................................................................................................. 346 5.6.1 Type-Traits........................ 346 5.6.2 Fibonacci-
Sequenz........................................................... 346 5.6.3 Meta-Programm für den größten gemeinsamen Divisor......................... 346 5.6.4 Rationale Zahlen mit gemischten Typen........................ 347 5.6.5 Vektor-Expression-Template..................................................................... 347 5.6.6 Meta-Liste................................................................................................... 348
XXII Inhalt ļļ Objektorientierte Programmierung................................................. 349 6.1 Grundprinzipien..................................................................................................... 349 6.1.1 Basis-und abgeleitete Klassen.................................................................. 350 6.1.2 Konstruktoren erben................................................................................... 353 6.1.3 Virtuelle Funktionen................................................................................... 354 6.1.4 Funktoren über Vererbung......................................................................... 361 6.1.5 Abgeleitete Klassen für Ausnahmen.......................................................... 362 6.2 Redundanz entfernen............................................................................................. 363 6.3 Mehrfachvererbung............................................................................................... 365 6.3.1 Mehrere Eltern............................................................................................. 365 6.3.2 Gemeinsame Großeltern............................................................................ 366 6.4 Dynamische Auswahl von Subtypen..................................................................... 371 6.5 Konvertierung..................................................... 373 6.5.1 Umwandlungen zwischen abgeleiteten Klassen....................................... 374 6.5.2
const_cast.................................................................................................. 378 6.5.3 Umdeutung.................................................................. 379 6.5.4 Umwandlung im Funktionsstil................................................................... 379 6.5.5 Implizite Umwandlungen........................................................................... 381 6.6 CRTP............................................. 382 6.6.1 Ein einfaches Beispiel ................................................................................ 382 6.6.2 Ein wiederverwendbarer Indexoperator................................................... 384 6.7 Übungen................................................................................................................. 386 6.7.1 Nicht-redundante Raute............................................................................ 386 6.7.2 Vektorklasse mit Vererbung........................................................................ 386 6.7.3 Ausnahmen in Vektor refaktorisieren....................................................... 386 6.7.4 Test auf geworfene Ausnahme.................................................................... 387 6.7.5 Klonfunktion............................................................................................... 387 Q Wissenschaftliche Projekte............................................................... 388 7.1 Implementierung von ODE-Lösern..................................................................... 388 7.1.1 Gewöhnliche
Differentialgleichungen...................................................... 388 7.1.2 Runge-Kutta-Algorithmen........................... 391 7.1.3 Generische Implementierung.................................................................... 392 7.1.4 Ausblick........................................................................................................ 399 7.2 Projekte erstellen................................................................................................... 399 7.2.1 Build-Prozess.............................................................................................. 400 7.2.2 Build-Tools.................................................................................................. 404 7.2.3 Separates Kompilieren................................................................................ 408 7.3 Einige abschließende Worte.................................................................................. 414
Inhalt XXIII Weitschweifendes.............................................................................. 416 A. 1 Mehr über gute und schlechte Software............................................................... 416 A.2 Grundlagen im Detail..................................................................... A.2.1 422 Statische Variablen..................................................................................... 422 A.2.2 Mehr über if.............................................................................................. 422 A.2.3 424 Duff’s Device.............................................................................................. A.2.4 Programmaufrufe...................................................................................... 424 A.2.5 Zusicherung oder Ausnahme?................................................................... 425 A.2.6 Binäre I/O.................................................................................................. 426 A.2.7 I/O im Stile von C...................................................................................... 427 A.2.8 Garbarge-Collection.................................................................................. 428 A.2.9 Ärger mit Makros....................................................................................... 429 A.3 Praxisbeispiel: Matrix-Invertierung...................................................................... 430 A.4 Massendetails................................................................................................. A.4.1 440 Zeiger auf
Mitglieder.................................................................................. 440 A.4.2 Weitere Initialisierungsbeispiele............................................................... 440 A.4.3 Zugriff auf mehrdimensionale Datenstrukturen...................................... 441 A.5 Methodengenerierung.......................................................................................... 444 A.5.1 Automatische Generierung....................................................................... 445 A.5.2 Steuerung der Generierung....................................................................... 447 A.5.3 Generierungsregeln................................................................................... 448 A.5.4 Fallstricke und Designrichtlinien............................................................. 452 A.6 Template-Details................................................................................................... 456 A.6.1 Einheitliche Initialisierung......................................................................... 456 A.6.2 Welche Funktion wird aufgerufen?........................................................... 456 A.6.3 Spezialisierung auf spezifische Hardware................................................ 459 A.6.4 Variadisches binäres I/O........................................................................... 460 A.7 Mehr über Bibliotheken........................................................................................ 461 A.7.1 std: : vector in C++03
verwenden.............................................................. 461 A.7.2 variant mal nerdisch................................................................................. 462 A.8 Dynamische Auswahl im alten Stil....................................................................... 462 A.9 Mehr über Meta-Programmierung....................................................................... 463 A.9.1 Das erste Meta-Programm in der Geschichte.......................................... 463 A.9.2 Meta-Funktionen........................................................................................ 465 A.9.3 Rückwärtskompatible statische Zusicherung.......................................... 466 A.9.4 Anonyme lypparameter........................................................................... 467 A.9.5 Benchmark-Quellen für dynamisches Abrollen...................................... 471 A.9.6 Benchmark für Matrixprodukt.................................................................. 472
XXIV Inhalt Q Werkzeuge.............................................................................. 473 B.l g++........................................................................................................................... 473 B.2 Debugging.............................................................................................................. 474 В.2.1 Textbasierte Debugger......................................... 474 B.2.2 Debugging mit graphischen Interface: DDD............................................ 476 B.3 Speicheranalyse...................................................................................................... 478 B.4 gnuplot.................................................................................................................... 479 B.5 Unix, Linux und Mac OS........................................................................................ 480 ¡Ц Sprachdefinitionen.............................................................................. 482 C.l Wertkategorien....................................................................................................... 482 C.2 Konvertierungsregeln............................................................................................ 485 C.2.1 Aufwertung.................................................................................................. 486 C.2.2 Andere Konvertierungen............................................................................ 486 C.2.3 Arithmetische Konvertierungen................................................................. 487
C.2.4 Verengung................................................................................................... Literatur......................................... 488 489 Abbildungsverzeichnis.............................................................................. 492 Tabellenverzeichnis.................................................................................... 493 Index..............................................................................................................494
|
| any_adam_object | 1 |
| author | Gottschling, Peter 1967- |
| author_GND | (DE-588)124235832 |
| author_facet | Gottschling, Peter 1967- |
| author_role | aut |
| author_sort | Gottschling, Peter 1967- |
| author_variant | p g pg |
| building | Verbundindex |
| bvnumber | BV045400998 |
| classification_rvk | ST 250 |
| classification_tum | DAT 358f |
| ctrlnum | (OCoLC)1079440184 (DE-599)DNB1173270469 |
| discipline | Informatik |
| format | Book |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>02302nam a2200565 c 4500</leader><controlfield tag="001">BV045400998</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20210326 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">190115s2019 gw |||| |||| 00||| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">18,N51</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">1173270469</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783446458468</subfield><subfield code="c">kart. : EUR 44.90 (DE)</subfield><subfield code="9">978-3-446-45846-8</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3446458468</subfield><subfield code="9">3-446-45846-8</subfield></datafield><datafield tag="024" ind1="3" ind2=" "><subfield code="a">9783446458468</subfield></datafield><datafield tag="028" ind1="5" ind2="2"><subfield code="a">Bestellnummer: 553/45846</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1079440184</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB1173270469</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</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">XA-DE-BY</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-M347</subfield><subfield code="a">DE-860</subfield><subfield code="a">DE-92</subfield><subfield code="a">DE-1050</subfield><subfield code="a">DE-706</subfield><subfield code="a">DE-210</subfield><subfield code="a">DE-20</subfield><subfield code="a">DE-91G</subfield><subfield code="a">DE-83</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-12</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-1046</subfield><subfield code="a">DE-11</subfield><subfield code="a">DE-1028</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">Gottschling, Peter</subfield><subfield code="d">1967-</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)124235832</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Forschung mit modernem C++</subfield><subfield code="b">C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer</subfield><subfield code="c">Peter Gottschling</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">München</subfield><subfield code="b">Hanser</subfield><subfield code="c">[2019]</subfield></datafield><datafield tag="264" ind1=" " ind2="4"><subfield code="c">© 2019</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XXIV, 504 Seiten</subfield><subfield code="b">Diagramme</subfield><subfield code="c">24 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="650" ind1="0" ind2="7"><subfield code="a">C++17</subfield><subfield code="0">(DE-588)1147325278</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="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">Programmierung</subfield><subfield code="0">(DE-588)4076370-5</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Wissenschaft</subfield><subfield code="0">(DE-588)4066562-8</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Forschung</subfield><subfield code="0">(DE-588)4017894-8</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Mixed media product</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="1"><subfield code="a">Wissenschaft</subfield><subfield code="0">(DE-588)4066562-8</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2="2"><subfield code="a">Forschung</subfield><subfield code="0">(DE-588)4017894-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">C++17</subfield><subfield code="0">(DE-588)1147325278</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2="1"><subfield code="a">Programmierung</subfield><subfield code="0">(DE-588)4076370-5</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2="2"><subfield code="a">Forschung</subfield><subfield code="0">(DE-588)4017894-8</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe</subfield><subfield code="z">978-3-446-45981-6</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau - ADAM Catalogue Enrichment</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=030787088&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-030787088</subfield></datafield></record></collection> |
| id | DE-604.BV045400998 |
| illustrated | Not Illustrated |
| indexdate | 2024-07-10T08:17:11Z |
| institution | BVB |
| isbn | 9783446458468 3446458468 |
| language | German |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-030787088 |
| oclc_num | 1079440184 |
| open_access_boolean | |
| owner | DE-M347 DE-860 DE-92 DE-1050 DE-706 DE-210 DE-20 DE-91G DE-BY-TUM DE-83 DE-Aug4 DE-739 DE-12 DE-634 DE-1046 DE-11 DE-1028 |
| owner_facet | DE-M347 DE-860 DE-92 DE-1050 DE-706 DE-210 DE-20 DE-91G DE-BY-TUM DE-83 DE-Aug4 DE-739 DE-12 DE-634 DE-1046 DE-11 DE-1028 |
| physical | XXIV, 504 Seiten Diagramme 24 cm |
| publishDate | 2019 |
| publishDateSearch | 2019 |
| publishDateSort | 2019 |
| publisher | Hanser |
| record_format | marc |
| spelling | Gottschling, Peter 1967- Verfasser (DE-588)124235832 aut Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer Peter Gottschling München Hanser [2019] © 2019 XXIV, 504 Seiten Diagramme 24 cm txt rdacontent n rdamedia nc rdacarrier C++17 (DE-588)1147325278 gnd rswk-swf C++ (DE-588)4193909-8 gnd rswk-swf Programmierung (DE-588)4076370-5 gnd rswk-swf Wissenschaft (DE-588)4066562-8 gnd rswk-swf Forschung (DE-588)4017894-8 gnd rswk-swf Mixed media product C++ (DE-588)4193909-8 s Wissenschaft (DE-588)4066562-8 s Forschung (DE-588)4017894-8 s DE-604 C++17 (DE-588)1147325278 s Programmierung (DE-588)4076370-5 s Erscheint auch als Online-Ausgabe 978-3-446-45981-6 Digitalisierung UB Passau - ADAM Catalogue Enrichment application/pdf http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=030787088&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA Inhaltsverzeichnis |
| spellingShingle | Gottschling, Peter 1967- Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer C++17 (DE-588)1147325278 gnd C++ (DE-588)4193909-8 gnd Programmierung (DE-588)4076370-5 gnd Wissenschaft (DE-588)4066562-8 gnd Forschung (DE-588)4017894-8 gnd |
| subject_GND | (DE-588)1147325278 (DE-588)4193909-8 (DE-588)4076370-5 (DE-588)4066562-8 (DE-588)4017894-8 |
| title | Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer |
| title_auth | Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer |
| title_exact_search | Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer |
| title_full | Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer Peter Gottschling |
| title_fullStr | Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer Peter Gottschling |
| title_full_unstemmed | Forschung mit modernem C++ C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer Peter Gottschling |
| title_short | Forschung mit modernem C++ |
| title_sort | forschung mit modernem c c 17 intensivkurs fur wissenschaftler ingenieure und programmierer |
| title_sub | C++17-Intensivkurs für Wissenschaftler, Ingenieure und Programmierer |
| topic | C++17 (DE-588)1147325278 gnd C++ (DE-588)4193909-8 gnd Programmierung (DE-588)4076370-5 gnd Wissenschaft (DE-588)4066562-8 gnd Forschung (DE-588)4017894-8 gnd |
| topic_facet | C++17 C++ Programmierung Wissenschaft Forschung |
| url | http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=030787088&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |
| work_keys_str_mv | AT gottschlingpeter forschungmitmodernemcc17intensivkursfurwissenschaftleringenieureundprogrammierer |