Hilfe Warenkorb Konto Anmelden
 
 
   Schnellsuche   
     zur Expertensuche                      
Der C++-Programmierer - C++ lernen - professionell anwenden - Lösungen nutzen.Aktuell zu C++17
  Großes Bild
 
Der C++-Programmierer - C++ lernen - professionell anwenden - Lösungen nutzen.Aktuell zu C++17
von: Ulrich Breymann
Carl Hanser Fachbuchverlag, 2017
ISBN: 9783446453869
1010 Seiten, Download: 22321 KB
 
Format:  PDF
geeignet für: Apple iPad, Android Tablet PC's Online-Lesen PC, MAC, Laptop

Typ: A (einfacher Zugriff)

 

 
eBook anfordern
Inhaltsverzeichnis

  Inhaltsverzeichnis 6  
  Vorwort 24  
  Teil I: Einführung in C++ 28  
     1 Es geht los! 30  
        1.1 Historisches 30  
        1.2 Objektorientierte Programmierung 31  
        1.3 Werkzeuge zum Programmieren 33  
        1.4 Das erste Programm 34  
           1.4.1 Namenskonventionen 40  
        1.5 Integrierte Entwicklungsumgebung 40  
        1.6 Einfache Datentypen und Operatoren 43  
           1.6.1 Ausdruck 43  
           1.6.2 Ganze Zahlen 43  
           1.6.3 Reelle Zahlen 50  
           1.6.4 Konstanten 54  
           1.6.5 Zeichen 55  
           1.6.6 Logischer Datentyp bool 59  
           1.6.7 Referenzen 60  
           1.6.8 Regeln zum Bilden von Ausdrücken 61  
           1.6.9 Standard-Typumwandlungen 62  
        1.7 Gültigkeitsbereich und Sichtbarkeit 63  
           1.7.1 Namespace std 65  
        1.8 Kontrollstrukturen 66  
           1.8.1 Anweisungen 66  
           1.8.2 Sequenz (Reihung) 68  
           1.8.3 Auswahl (Selektion, Verzweigung) 68  
           1.8.4 Fallunterscheidungen mit switch 73  
           1.8.5 Wiederholungen 76  
           1.8.6 Kontrolle mit break und continue 83  
        1.9 Benutzerdefinierte und zusammengesetzte Datentypen 85  
           1.9.1 Aufzählungstypen 85  
           1.9.2 Strukturen 88  
           1.9.3 Der C++-Standardtyp vector 89  
           1.9.4 Zeichenketten: Der C++-Standardtyp string 94  
           1.9.5 Container und Schleifen 96  
           1.9.6 Typermittlung mit auto 98  
           1.9.7 Deklaration einer strukturierten Bindung mit auto 99  
           1.9.8 Unions und Bitfelder 100  
        1.10 Einfache Ein- und Ausgabe 102  
           1.10.1 Standardein- und -ausgabe 102  
           1.10.2 Ein- und Ausgabe mit Dateien 105  
     2 Programmstrukturierung 110  
        2.1 Funktionen 110  
           2.1.1 Aufbau und Prototypen 111  
           2.1.2 Gültigkeitsbereiche und Sichtbarkeit in Funktionen 113  
           2.1.3 Lokale static-Variable: Funktion mit Gedächtnis 114  
        2.2 Schnittstellen zum Datentransfer 115  
           2.2.1 Übergabe per Wert 116  
           2.2.2 Übergabe per Referenz 120  
           2.2.3 Gefahren bei der Rückgabe von Referenzen 121  
           2.2.4 Vorgegebene Parameterwerte und unterschiedliche Parameterzahl 122  
           2.2.5 Überladen von Funktionen 123  
           2.2.6 Funktion main() 124  
           2.2.7 Beispiel Taschenrechnersimulation 125  
           2.2.8 Spezifikation von Funktionen 130  
           2.2.9 Alternative Funktions-Syntax 130  
        2.3 Modulare Programmgestaltung 130  
           2.3.1 Steuerung der Übersetzung nur mit #include 131  
           2.3.2 Einbinden vorübersetzter Programmteile 131  
           2.3.3 Übersetzungseinheit, Deklaration, Definition 133  
           2.3.4 Dateiübergreifende Gültigkeit und Sichtbarkeit 135  
           2.3.5 Präprozessordirektiven und Makros 137  
        2.4 Namensräume 145  
        2.5 inline-Funktionen und -Variable 147  
           2.5.1 inline-Variablen 148  
        2.6 constexpr-Funktionen 148  
        2.7 Rückgabetyp auto 150  
        2.8 Funktions-Templates 152  
           2.8.1 Spezialisierung von Templates 154  
           2.8.2 Einbinden von Templates 155  
        2.9 C++-Header 157  
           2.9.1 Einbinden von C-Funktionen 159  
     3 Objektorientierung 1 160  
        3.1 Abstrakter Datentyp 161  
        3.2 Klassen und Objekte 162  
           3.2.1 const-Objekte und Methoden 165  
           3.2.2 inline-Elementfunktionen 166  
        3.3 Initialisierung und Konstruktoren 167  
           3.3.1 Standardkonstruktor 167  
           3.3.2 Direkte Initialisierung der Attribute 169  
           3.3.3 Allgemeine Konstruktoren 169  
           3.3.4 Kopierkonstruktor 172  
           3.3.5 Typumwandlungskonstruktor 175  
           3.3.6 Konstruktor und mehr vorgeben oder verbieten 177  
           3.3.7 Einheitliche Initialisierung und Sequenzkonstruktor 177  
           3.3.8 Delegierender Konstruktor 180  
           3.3.9 constexpr-Konstruktor und -Methoden 181  
        3.4 Beispiel: Rationale Zahlen 184  
           3.4.1 Aufgabenstellung 184  
           3.4.2 Entwurf 185  
           3.4.3 Implementation 188  
        3.5 Destruktoren 193  
        3.6 Wie kommt man zu Klassen und Objekten? Ein Beispiel 195  
        3.7 Gegenseitige Abhängigkeit von Klassen 200  
     4 Intermezzo: Zeiger 202  
        4.1 Zeiger und Adressen 203  
        4.2 C-Arrays 206  
           4.2.1 C-Array, std::size() und sizeof 208  
           4.2.2 Initialisierung von C-Arrays 209  
           4.2.3 Zeigerarithmetik 209  
           4.2.4 Indexoperator bei C-Arrays 210  
           4.2.5 C-Array mit begin() und end() durchlaufen 210  
        4.3 C-Zeichenketten 211  
           4.3.1 Schleifen und C-Strings 214  
        4.4 Dynamische Datenobjekte 218  
           4.4.1 Freigeben dynamischer Objekte 221  
        4.5 Zeiger und Funktionen 223  
           4.5.1 Parameterübergabe mit Zeigern 223  
           4.5.2 Array als Funktionsparameter 225  
           4.5.3 const und Zeiger-Parameter 226  
           4.5.4 Parameter des main-Programms 226  
           4.5.5 Gefahren bei der Rückgabe von Zeigern 227  
        4.6 this-Zeiger 228  
        4.7 Mehrdimensionale C-Arrays 230  
           4.7.1 Statische mehrdimensionale C-Arrays 230  
           4.7.2 Mehrdimensionales Array als Funktionsparameter 231  
           4.7.3 Dynamisch erzeugte mehrdimensionale Arrays 234  
           4.7.4 Klasse für dynamisches zweidimensionales Array 236  
        4.8 Binäre Ein-/Ausgabe 242  
        4.9 Zeiger auf Funktionen 245  
        4.10 Typumwandlungen für Zeiger 249  
        4.11 Zeiger auf Elementfunktionen und -daten 250  
           4.11.1 Zeiger auf Elementfunktionen 250  
           4.11.2 Zeiger auf Elementdaten 251  
        4.12 Komplexe Deklarationen lesen 251  
           4.12.1 Lesbarkeit mit typedef und using verbessern 252  
        4.13 Alternative zu rohen Zeigern, new und delete 254  
     5 Objektorientierung 2 256  
        5.1 Eine String-Klasse 256  
           5.1.1 friend-Funktionen 262  
        5.2 String-Ansicht 263  
        5.3 Klassenspezifische Daten und Funktionen 266  
           5.3.1 Klassenspezifische Konstante 270  
        5.4 Klassen-Templates 272  
           5.4.1 Ein Stack-Template 272  
           5.4.2 Stack mit statisch festgelegter Größe 274  
        5.5 Typbestimmung mit decltype und declval 276  
     6 Vererbung 280  
        6.1 Vererbung und Initialisierung 286  
        6.2 Zugriffsschutz 287  
        6.3 Typbeziehung zwischen Ober- und Unterklasse 289  
        6.4 Code-Wiederverwendung 290  
           6.4.1 Konstruktor erben 291  
        6.5 Überschreiben von Funktionen in abgeleiteten Klassen 293  
           6.5.1 Virtuelle Funktionen 295  
           6.5.2 Abstrakte Klassen 300  
           6.5.3 Virtueller Destruktor 305  
           6.5.4 Private virtuelle Funktionen 308  
        6.6 Probleme der Modellierung mit Vererbung 310  
        6.7 Mehrfachvererbung 313  
           6.7.1 Namenskonflikte 315  
           6.7.2 Virtuelle Basisklassen 316  
        6.8 Standard-Typumwandlungsoperatoren 320  
        6.9 Typinformationen zur Laufzeit 323  
        6.10 Using-Deklaration für protected-Funktionen 324  
        6.11 Private- und Protected-Vererbung 325  
     7 Fehlerbehandlung 330  
        7.1 Ausnahmebehandlung 332  
           7.1.1 Exception-Spezifikation in Deklarationen 335  
           7.1.2 Exception-Hierarchie in C++ 336  
           7.1.3 Besondere Fehlerbehandlungsfunktionen 338  
           7.1.4 Erkennen logischer Fehler 339  
           7.1.5 Arithmetische Fehler / Division durch 0 341  
        7.2 Speicherbeschaffung mit new 342  
        7.3 Exception-Sicherheit 343  
     8 Überladen von Operatoren 346  
        8.1 Rationale Zahlen — noch einmal 348  
           8.1.1 Arithmetische Operatoren 348  
           8.1.2 Ausgabeoperator << 350  
        8.2 Eine Klasse für Vektoren 352  
           8.2.1 Index-Operator [ ] 355  
           8.2.2 Zuweisungsoperator = 357  
           8.2.3 Mathematische Vektoren 360  
           8.2.4 Multiplikationsoperator 361  
        8.3 Inkrement-Operator ++ 362  
        8.4 Typumwandlungsoperator 366  
        8.5 Smart Pointer: Operatoren -> und * 368  
           8.5.1 Smart Pointer und die C++-Standardbibliothek 373  
        8.6 Objekt als Funktion 374  
        8.7 new und delete überladen 376  
           8.7.1 Unterscheidung zwischen Heap- und Stack-Objekten 379  
           8.7.2 Fehlende delete-Anweisung entdecken 381  
           8.7.3 Eigene Speicherverwaltung für einen bestimmten Typ 382  
           8.7.4 Empfehlungen im Umgang mit new und delete 386  
        8.8 Operatoren für Literale 387  
           8.8.1 Stringliterale 388  
           8.8.2 Benutzerdefinierte Literale 389  
        8.9 Mehrdimensionale Matrizen 391  
           8.9.1 Zweidimensionale Matrix als Vektor von Vektoren 392  
           8.9.2 Dreidimensionale Matrix 395  
        8.10 Zuweisung und Vergleich bei Vererbung 397  
     9 Dateien und Ströme 406  
        9.1 Ausgabe 408  
           9.1.1 Formatierung der Ausgabe 408  
        9.2 Eingabe 411  
        9.3 Manipulatoren 414  
           9.3.1 Eigene Manipulatoren 419  
        9.4 Fehlerbehandlung 421  
        9.5 Typumwandlung von Dateiobjekten nach bool 422  
        9.6 Arbeit mit Dateien 423  
           9.6.1 Positionierung in Dateien 424  
           9.6.2 Lesen und Schreiben in derselben Datei 425  
        9.7 Umleitung auf Strings 426  
        9.8 Tabelle formatiert ausgeben 428  
        9.9 Formatierte Daten lesen 429  
           9.9.1 Eingabe benutzerdefinierter Typen 429  
        9.10 Blockweise lesen und schreiben 430  
           9.10.1 vector-Objekt binär lesen und schreiben 431  
           9.10.2 array-Objekt binär lesen und schreiben 432  
           9.10.3 Matrix binär lesen und schreiben 433  
        9.11 Ergänzungen 435  
     10 Die Standard Template Library (STL) 436  
        10.1 Container, Iteratoren, Algorithmen 437  
        10.2 Iteratoren im Detail 442  
        10.3 Beispiel verkettete Liste 443  
  Teil II: Fortgeschrittene Themen 448  
     11 Performance, Wert- und Referenzsemantik 450  
        11.1 Performanceproblem Wertsemantik 451  
           11.1.1 Auslassen der Kopie 452  
           11.1.2 Temporäre Objekte bei der Zuweisung 453  
        11.2 Referenzsemantik für R-Werte 454  
        11.3 Optimierung durch Referenzsemantik für R-Werte 456  
           11.3.1 Bewegender Konstruktor 459  
           11.3.2 Bewegender Zuweisungsoperator 459  
        11.4 Die move()-Funktion 460  
           11.4.1 Regel zur Template-Auswertung von &&-Parametern 462  
        11.5 Ein effizienter binärer Plusoperator 463  
           11.5.1 Return Value Optimization (RVO) 464  
           11.5.2 Kopien temporärer Objekte eliminieren 464  
           11.5.3 Verbesserung durch verzögerte Auswertung 465  
           11.5.4 Weitere Optimierungsmöglichkeiten 467  
        11.6 Rule of three/five/zero 468  
           11.6.1 Rule of three 468  
           11.6.2 Rule of five 468  
           11.6.3 Rule of zero 469  
     12 Lambda-Funktionen 470  
        12.1 Eigenschaften 471  
           12.1.1 Äquivalenz zum Funktionszeiger 472  
           12.1.2 Lambda-Funktion und Klasse 473  
        12.2 Generische Lambda-Funktionen 473  
        12.3 Parametererfassung mit [] 476  
     13 Template-Metaprogrammierung 478  
        13.1 Grundlagen 478  
        13.2 Variadic Templates: Templates mit variabler Parameterzahl 481  
           13.2.1 Ablauf der Auswertung durch den Compiler 482  
           13.2.2 Anzahl der Parameter 483  
           13.2.3 Parameterexpansion 483  
        13.3 Fold-Expressions 485  
           13.3.1 Weitere Varianten 486  
           13.3.2 Fold-Expression mit Kommaoperator 487  
        13.4 Klassen-Template mit variabler Stelligkeit 489  
     14 Reguläre Ausdrücke 490  
        14.1 Elemente regulärer Ausdrücke 491  
           14.1.1 Greedy oder lazy? 493  
        14.2 Interaktive Auswertung 494  
        14.3 Auszug des regex-API 497  
        14.4 Verarbeitung von \n 499  
        14.5 Anwendungen 500  
     15 Threads 502  
        15.1 Zeit und Dauer 503  
        15.2 Threads 504  
        15.3 Die Klasse thread 508  
           15.3.1 Thread-Group 510  
        15.4 Synchronisation kritischer Abschnitte 511  
        15.5 Thread-Steuerung: Pausieren, Fortsetzen, Beenden 514  
           15.5.1 Data Race 519  
        15.6 Warten auf Ereignisse 519  
        15.7 Reader/Writer-Problem 525  
           15.7.1 Wenn Threads verhungern 529  
           15.7.2 Reader/Writer-Varianten 530  
        15.8 Atomare Veränderung von Variablen 530  
        15.9 Asynchrone verteilte Bearbeitung einer Aufgabe 533  
        15.10 Thread-Sicherheit 535  
     16 Grafische Benutzungsschnittstellen 536  
        16.1 Ereignisgesteuerte Programmierung 537  
        16.2 GUI-Programmierung mit Qt 538  
           16.2.1 Installation und Einsatz 538  
           16.2.2 Meta-Objektsystem 539  
           16.2.3 Der Programmablauf 540  
           16.2.4 Ereignis abfragen 541  
        16.3 Signale, Slots und Widgets 542  
        16.4 Dialog 551  
        16.5 Qt oder Standard-C++? 554  
           16.5.1 Threads 555  
           16.5.2 Verzeichnisbaum durchwandern 556  
     17 Internet-Anbindung 558  
        17.1 Protokolle 559  
        17.2 Adressen 559  
        17.3 Socket 563  
           17.3.1 Bidirektionale Kommunikation 566  
           17.3.2 UDP-Sockets 568  
           17.3.3 Atomuhr mit UDP abfragen 569  
        17.4 HTTP 572  
           17.4.1 Verbindung mit GET 573  
           17.4.2 Verbindung mit POST 578  
        17.5 Mini-Webserver 579  
     18 Datenbankanbindung 588  
        18.1 C++-Interface 589  
        18.2 Anwendungsbeispiel 593  
  Teil III: Ausgewählte Methoden und Werkzeuge der Softwareentwicklung 600  
     19 Effiziente Programmerzeugung mit make 602  
        19.1 Wirkungsweise 604  
        19.2 Variablen und Muster 606  
        19.3 Universelles Makefile für einfache Projekte 607  
        19.4 Automatische Ermittlung von Abhängigkeiten 608  
           19.4.1 Getrennte Verzeichnisse: src, obj, bin 610  
        19.5 Makefile für Verzeichnisbäume 612  
           19.5.1 Rekursive Make-Aufrufe 613  
           19.5.2 Ein Makefile für alles 615  
        19.6 Automatische Erzeugung von Makefiles 616  
           19.6.1 Makefile für rekursive Aufrufe erzeugen 617  
        19.7 Erzeugen von Bibliotheken 618  
           19.7.1 Statische Bibliotheksmodule 618  
           19.7.2 Dynamische Bibliotheksmodule 620  
        19.8 Code Bloat bei der Instanziierung von Templates vermeiden 623  
           19.8.1 extern-Template 624  
        19.9 CMake 625  
        19.10 GNU Autotools 627  
     20 Unit-Test 628  
        20.1 Werkzeuge 629  
        20.2 Test Driven Development 630  
        20.3 Boost Unit Test Framework 631  
           20.3.1 Beispiel: Testgetriebene Entwicklung einer Operatorfunktion 633  
           20.3.2 Fixture 637  
           20.3.3 Testprotokoll und Log-Level 638  
           20.3.4 Prüf-Makros 639  
           20.3.5 Kommandozeilen-Optionen 643  
  Teil IV: Das C++-Rezeptbuch: Tipps und Lösungen für typische Aufgaben 644  
     21 Sichere Programmentwicklung 646  
        21.1 Regeln zum Design von Methoden 646  
        21.2 Defensive Programmierung 648  
           21.2.1 double- und float-Werte richtig vergleichen 649  
           21.2.2 const und constexpr verwenden 650  
           21.2.3 Anweisungen nach for/if/while einklammern 650  
           21.2.4 int und unsigned/size_t nicht mischen 650  
           21.2.5 size_t oder auto statt unsigned int verwenden 651  
           21.2.6 Postfix++ mit Präfix++ implementieren 651  
           21.2.7 Ein Destruktor darf keine Exception werfen 652  
           21.2.8 explicit-Typumwandlungsoperator bevorzugen 652  
           21.2.9 explicit-Konstruktor für eine Typumwandlung bevorzugen 652  
           21.2.10 Leere Standardkonstruktoren vermeiden 652  
           21.2.11 Mit override Schreibfehler reduzieren 652  
           21.2.12 Kopieren und Zuweisung verbieten 652  
           21.2.13 Vererbung verbieten 653  
           21.2.14 Überschreiben einer virtuellen Methode verhindern 654  
           21.2.15 >>Rule of zero<< beachten 654  
           21.2.16 One Definition Rule 654  
           21.2.17 Defensiv Objekte löschen 654  
           21.2.18 Speicherbeschaffung und -freigabe kapseln 655  
           21.2.19 Programmierrichtlinien einhalten 655  
        21.3 Exception-sichere Beschaffung von Ressourcen 655  
           21.3.1 Sichere Verwendung von unique_ptr und shared_ptr 655  
           21.3.2 So vermeiden Sie new und delete! 656  
           21.3.3 shared_ptr für Arrays korrekt verwenden 657  
           21.3.4 unique_ptr für Arrays korrekt verwenden 658  
           21.3.5 Exception-sichere Funktion 659  
           21.3.6 Exception-sicherer Konstruktor 659  
           21.3.7 Exception-sichere Zuweisung 660  
        21.4 Empfehlungen zur Thread-Programmierung 661  
           21.4.1 Warten auf die Freigabe von Ressourcen 661  
           21.4.2 Deadlock-Vermeidung 662  
           21.4.3 notify_all oder notify_one? 662  
           21.4.4 Performance mit Threads verbessern? 663  
     22 Von der UML nach C++ 664  
        22.1 Vererbung 664  
        22.2 Interface anbieten und nutzen 665  
        22.3 Assoziation 667  
           22.3.1 Aggregation 670  
           22.3.2 Komposition 670  
     23 Algorithmen für verschiedene Aufgaben 672  
        23.1 Algorithmen mit Strings 673  
           23.1.1 String splitten 673  
           23.1.2 String in Zahl umwandeln 674  
           23.1.3 Zahl in String umwandeln 676  
           23.1.4 Strings sprachlich richtig sortieren 677  
           23.1.5 Umwandlung in Klein- bzw. Großschreibung 679  
           23.1.6 Strings sprachlich richtig vergleichen 681  
           23.1.7 Von der Groß-/Kleinschreibung unabhängiger Zeichenvergleich 682  
           23.1.8 Von der Groß-/Kleinschreibung unabhängige Suche 683  
        23.2 Textverarbeitung 684  
           23.2.1 Datei durchsuchen 684  
           23.2.2 Ersetzungen in einer Datei 686  
           23.2.3 Lines of Code (LOC) ermitteln 688  
           23.2.4 Zeilen, Wörter und Zeichen einer Datei zählen 689  
           23.2.5 CSV-Datei lesen 689  
           23.2.6 Kreuzreferenzliste 690  
        23.3 Operationen auf Folgen 693  
           23.3.1 Container anzeigen 694  
           23.3.2 Folge mit gleichen Werten initialisieren 694  
           23.3.3 Folge mit Werten eines Generators initialisieren 695  
           23.3.4 Folge mit fortlaufenden Werten initialisieren 695  
           23.3.5 Summe und Produkt 696  
           23.3.6 Mittelwert und Standardabweichung 697  
           23.3.7 Skalarprodukt 697  
           23.3.8 Folge der Teilsummen oder -produkte 698  
           23.3.9 Folge der Differenzen 699  
           23.3.10 Kleinstes und größtes Element finden 700  
           23.3.11 Elemente rotieren 702  
           23.3.12 Elemente verwürfeln 703  
           23.3.13 Dubletten entfernen 703  
           23.3.14 Reihenfolge umdrehen 705  
           23.3.15 Stichprobe 706  
           23.3.16 Anzahl der Elemente, die einer Bedingung genügen 707  
           23.3.17 Gilt ein Prädikat für alle, keins oder wenigstens ein Element einer Folge? 708  
           23.3.18 Permutationen 709  
           23.3.19 Lexikografischer Vergleich 712  
        23.4 Sortieren und Verwandtes 713  
           23.4.1 Partitionieren 713  
           23.4.2 Sortieren 715  
           23.4.3 Stabiles Sortieren 716  
           23.4.4 Partielles Sortieren 717  
           23.4.5 Das n.-größte oder n.-kleinste Element finden 718  
           23.4.6 Verschmelzen (merge) 719  
        23.5 Suchen und Finden 722  
           23.5.1 Element finden 722  
           23.5.2 Element einer Menge in der Folge finden 723  
           23.5.3 Teilfolge finden 724  
           23.5.4 Teilfolge mit speziellem Algorithmus finden 725  
           23.5.5 Bestimmte benachbarte Elemente finden 727  
           23.5.6 Bestimmte aufeinanderfolgende Werte finden 728  
           23.5.7 Binäre Suche 729  
        23.6 Mengenoperationen auf sortierten Strukturen 731  
           23.6.1 Teilmengenrelation 732  
           23.6.2 Vereinigung 733  
           23.6.3 Schnittmenge 734  
           23.6.4 Differenz 734  
           23.6.5 Symmetrische Differenz 735  
        23.7 Heap-Algorithmen 736  
           23.7.1 pop_heap 737  
           23.7.2 push_heap 738  
           23.7.3 make_heap 738  
           23.7.4 sort_heap 739  
           23.7.5 is_heap 739  
        23.8 Vergleich von Containern auch ungleichen Typs 740  
           23.8.1 Unterschiedliche Elemente finden 740  
           23.8.2 Prüfung auf gleiche Inhalte 742  
        23.9 Rechnen mit komplexen Zahlen: Der C++-Standardtyp complex 743  
        23.10 Schnelle zweidimensionale Matrix 745  
           23.10.1 Optimierung mathematischer Array-Operationen 748  
        23.11 Vermischtes 751  
           23.11.1 Erkennung eines Datums 751  
           23.11.2 Erkennung einer IPv4-Adresse 753  
           23.11.3 Erzeugen von Zufallszahlen 754  
           23.11.4 for_each — Auf jedem Element eine Funktion ausführen 759  
           23.11.5 Verschiedene Möglichkeiten, Container-Bereiche zu kopieren 759  
           23.11.6 Vertauschen von Elementen, Bereichen und Containern 762  
           23.11.7 Elemente transformieren 762  
           23.11.8 Ersetzen und Varianten 764  
           23.11.9 Elemente herausfiltern 765  
           23.11.10 Grenzwerte von Zahltypen 767  
           23.11.11 Minimum und Maximum 767  
           23.11.12 Wert begrenzen 769  
           23.11.13 ggT und kgV 770  
        23.12 Parallelisierbare Algorithmen 771  
     24 Datei- und Verzeichnisoperationen 772  
        24.1 Übersicht 773  
        24.2 Pfadoperationen 774  
        24.3 Datei oder Verzeichnis löschen 775  
           24.3.1 Möglicherweise gefülltes Verzeichnis löschen 776  
        24.4 Datei oder Verzeichnis kopieren 777  
        24.5 Datei oder Verzeichnis umbenennen 778  
        24.6 Verzeichnis anlegen 778  
        24.7 Verzeichnis anzeigen 779  
        24.8 Verzeichnisbaum anzeigen 780  
  Teil V: Die C++-Standardbibliothek 782  
     25 Aufbau und Übersicht 784  
        25.1 Auslassungen 786  
        25.2 Beispiele des Buchs und die C++-Standardbibliothek 787  
     26 Hilfsfunktionen und -klassen 790  
        26.1 Relationale Operatoren 790  
        26.2 Unterstützung der Referenzsemantik für R-Werte 791  
           26.2.1 move() 791  
           26.2.2 forward() 792  
        26.3 Paare 793  
        26.4 Tupel 795  
        26.5 bitset 797  
        26.6 Indexfolgen 800  
        26.7 variant statt union 801  
        26.8 Funktionsobjekte 802  
           26.8.1 Arithmetische, vergleichende und logische Operationen 802  
           26.8.2 Binden von Argumentwerten 803  
           26.8.3 Funktionen in Objekte umwandeln 805  
        26.9 Templates für rationale Zahlen 807  
        26.10 Hüllklasse für Referenzen 808  
        26.11 Optionale Objekte 809  
        26.12 Type Traits 811  
           26.12.1 Wie funktionieren Type Traits? — ein Beispiel 812  
           26.12.2 Abfrage von Eigenschaften 814  
           26.12.3 Abfrage numerischer Eigenschaften 816  
           26.12.4 Typbeziehungen 816  
           26.12.5 Typumwandlungen 817  
        26.13 Auswahl weiterer Traits 817  
           26.13.1 decay 817  
           26.13.2 enable_if 817  
           26.13.3 conditional 818  
           26.13.4 default_order 818  
     27 Container 820  
        27.1 Gemeinsame Eigenschaften 822  
           27.1.1 Initialisierungslisten 824  
           27.1.2 Konstruktion an Ort und Stelle 824  
           27.1.3 Reversible Container 825  
        27.2 Sequenzen 826  
           27.2.1 vector 827  
           27.2.2 vector 828  
           27.2.3 list 829  
           27.2.4 deque 832  
           27.2.5 stack 833  
           27.2.6 queue 835  
           27.2.7 priority_queue 837  
           27.2.8 array 839  
        27.3 Assoziative Container 841  
        27.4 Sortierte assoziative Container 843  
           27.4.1 map und multimap 844  
           27.4.2 set und multiset 848  
        27.5 Hash-Container 850  
           27.5.1 unordered_map und unordered_multimap 854  
           27.5.2 unordered_set und unordered_multiset 856  
     28 Iteratoren 858  
        28.1 Iterator-Kategorien 859  
           28.1.1 Anwendung von Traits 860  
        28.2 Abstand und Bewegen 863  
        28.3 Zugriff auf Anfang und Ende 864  
           28.3.1 Reverse-Iteratoren 865  
        28.4 Insert-Iteratoren 866  
        28.5 Stream-Iteratoren 867  
     29 Algorithmen 870  
        29.1 Algorithmen mit Prädikat 871  
        29.2 Übersicht 872  
     30 Nationale Besonderheiten 876  
        30.1 Sprachumgebung festlegen und ändern 876  
           30.1.1 Die locale-Funktionen 878  
        30.2 Zeichensätze und -codierung 880  
        30.3 Zeichenklassifizierung und -umwandlung 884  
        30.4 Kategorien 885  
           30.4.1 collate 885  
           30.4.2 ctype 886  
           30.4.3 numeric 888  
           30.4.4 monetary 889  
           30.4.5 time 892  
           30.4.6 messages 894  
        30.5 Konstruktion eigener Facetten 896  
     31 String 898  
        31.1 string_view für String-Literale 908  
     32 Speichermanagement 910  
        32.1 unique_ptr 910  
           32.1.1 make_unique 912  
        32.2 shared_ptr 913  
           32.2.1 make_shared 914  
           32.2.2 Typumwandlung in einen Oberklassentyp 914  
        32.3 weak_ptr 915  
        32.4 new mit Speicherortangabe 916  
     33 Numerische Arrays (valarray) 918  
        33.1 Konstruktoren 919  
        33.2 Elementfunktionen 919  
        33.3 Binäre Valarray-Operatoren 922  
        33.4 Mathematische Funktionen 924  
        33.5 slice und slice_array 925  
        33.6 gslice und gslice_array 928  
        33.7 mask_array 931  
        33.8 indirect_array 932  
     34 Ausgewählte C-Header 934  
        34.1 934  
        34.2 935  
        34.3 935  
        34.4 937  
        34.5 937  
        34.6 938  
        34.7 940  
  A Anhang 942  
     A.1 ASCII-Tabelle 942  
     A.2 C++-Schlüsselwörter 944  
     A.3 Compilerbefehle 945  
     A.4 Rangfolge der Operatoren 946  
     A.5 C++-Attribute für den Compiler 947  
     A.6 Lösungen zu den Übungsaufgaben 948  
     A.7 Installation der Software für Windows 958  
        A.7.1 Installation des Compilers und der Entwicklungsumgebung 958  
        A.7.2 Integrierte Entwicklungsumgebung einrichten 959  
        A.7.3 De-Installation 959  
     A.8 Installation der Software für Linux 960  
        A.8.1 Installation des Compilers 960  
        A.8.2 Installation von Boost 961  
        A.8.3 Installation und Einrichtung von Code::Blocks 961  
        A.8.4 Beispieldateien entpacken 962  
     A.9 Installationshinweise für OS X 962  
        A.9.1 Installation von Boost 962  
        A.9.2 Beispieldateien entpacken 963  
  Glossar 964  
  Literaturverzeichnis 974  
  Register 978  
  1001_1008_Breymann_5A_Anzeigen.pdf 1  
     CHV_Anz_Seite1001_Gloger_44723 1002  
     CHV_Anz_Seite1001_Gloger_44723 1003  
     CHV_Anz_Seite1003_Leopold_44343 1004  
     CHV_Anz_Seite1003_Leopold_44343 1005  
     CHV_Anz_Seite1005_FreundRücker_5A_45054 1006  
     CHV_Anz_Seite1005_FreundRücker_5A_45054 1007  
     CHV_Anz_Seite1007_Starke_7A_44361 1008  
     CHV_Anz_Seite1007_Starke_7A_44361 1009  


nach oben


  Mehr zum Inhalt
Kapitelübersicht
Kurzinformation
Inhaltsverzeichnis
Leseprobe
Blick ins Buch
Fragen zu eBooks?

  Medientyp
  eBooks
  eJournal
  alle

  Navigation
Belletristik / Romane
Computer
Geschichte
Kultur
Medizin / Gesundheit
Philosophie / Religion
Politik
Psychologie / Pädagogik
Ratgeber
Recht
Reise / Hobbys
Sexualität / Erotik
Technik / Wissen
Wirtschaft

  Info
Hier gelangen Sie wieder zum Online-Auftritt Ihrer Bibliothek
© 2008-2020 ciando GmbH | Impressum | Kontakt | F.A.Q. | Datenschutz