Will - C++ - 9783836243605

Name: C++
Price: 39.90 EUR
Availability: InStock
ISBN: 9783836243605

C++

Das umfassende Handbuch zu Modern C++ - aktuell zu C++17

Medium: Buch

ISBN: 978-3-8362-4360-5

Verlag: Rheinwerk Verlag GmbH

Erscheinungstermin: 31.01.2018

39,90 € 37,29 € (zzgl. MwSt.)

Nicht mehr lieferbar

Vorwort. 23

TEIL I  Grundlagen. 27

  1.  Das C++-Handbuch. 29

       1.1. Neu und Modern. 30

       1.2. 'Dan'-Kapitel. 30

       1.3. Darstellung in diesem Buch. 31

       1.4. Verwendete Formatierungen. 31

       1.5. Sorry for my Denglish. 32

  2.  Programmieren in C++. 35

       2.1. Übersetzen. 36

       2.2. Übersetzungsphasen. 36

       2.3. Aktuelle Compiler. 38

       2.4. Entwicklungsumgebungen. 39

       2.5. Die Kommandozeile unter Ubuntu. 40

       2.6. Die IDE 'Microsoft Visual Studio Community' unter Windows. 44

       2.7. Das Beispielprogramm beschleunigen. 46

  3.  C++ für Umsteiger. 49

  4.  Die Grundbausteine von C++. 55

       4.1. Kommentare. 58

       4.2. Die 'include'-Direktive. 58

       4.3. Die Standardbibliothek. 58

       4.4. Die Funktion 'main()'. 59

       4.5. Typen. 59

       4.6. Variablen. 60

       4.7. Initialisierung. 60

       4.8. Ausgabe auf der Konsole. 61

       4.9. Anweisungen. 61

       4.10. Ohne Eile erklärt. 62

       4.11. Operatoren. 85

       4.12. Eingebaute Datentypen. 98

       4.13. Undefiniertes und unspezifiziertes Verhalten. 132

  5.  Guter Code, 1. Dan: Lesbar programmieren. 135

       5.1. Kommentare. 135

       5.2. Dokumentation. 136

       5.3. Einrückungen und Zeilenlänge. 137

       5.4. Zeilen pro Funktion und Datei. 138

       5.5. Klammern und Leerzeichen. 139

       5.6. Namen. 140

  6.  Höhere Datentypen. 143

       6.1. Strings und Streams. 144

       6.2. Der Zeichenkettentyp 'string'. 144

       6.3. Streams. 148

       6.4. Behälter und Zeiger. 155

       6.5. Die einfachen Sequenzcontainer. 156

       6.6. Algorithmen. 161

       6.7. Zeiger und C-Arrays. 161

  7.  Funktionen. 163

       7.1. Deklaration und Definition einer Funktion. 164

       7.2. Funktionstyp. 165

       7.3. Funktionen verwenden. 165

       7.4. Eine Funktion definieren. 167

       7.5. Mehr zu Parametern. 168

       7.6. Funktionskörper. 172

       7.7. Parameter umwandeln. 173

       7.8. Funktionen überladen. 175

       7.9. Default-Parameter. 177

       7.10. Beliebig viele Argumente. 179

       7.11. Alternative Schreibweise zur Funktionsdeklaration. 179

       7.12. Spezialitäten. 180

  8.  Anweisungen im Detail. 185

       8.1. Der Anweisungsblock. 188

       8.2. Die leere Anweisung. 190

       8.3. Deklarationsanweisung. 191

       8.4. Die Ausdrucksanweisung. 192

       8.5. Die 'if'-Anweisung. 193

       8.6. Die 'while'-Schleife. 195

       8.7. Die 'do-while'-Schleife. 197

       8.8. Die 'for'-Schleife. 198

       8.9. Die bereichsbasierte 'for'-Schleife. 200

       8.10. Die 'switch'-Verzweigung. 202

       8.11. Die 'break'-Anweisung. 206

       8.12. Die 'continue'-Anweisung. 207

       8.13. Die 'return'-Anweisung. 207

       8.14. Die 'goto'-Anweisung. 209

       8.15. Der 'try-catch'-Block und 'throw'. 210

       8.16. Zusammenfassung. 212

  9.  Ausdrücke im Detail. 213

       9.1. Berechnungen und Seiteneffekte. 214

       9.2. Arten von Ausdrücken. 215

       9.3. Literale. 216

       9.4. Bezeichner. 216

       9.5. Klammern. 217

       9.6. Funktionsaufruf und Index-Zugriff. 218

       9.7. Zuweisung. 218

       9.8. Typumwandlung. 220

10.  Fehlerbehandlung. 221

       10.1. Fehlerbehandlung mit Fehlercodes. 223

       10.2. Was ist eine Ausnahme?. 226

       10.3. Kleinere Fehlerbehandlungen. 229

       10.4. Weiterwerfen -- 'rethrow'. 229

       10.5. Die Reihenfolge im 'catch'. 230

       10.6. Typen für Exceptions. 232

       10.7. Wenn eine Exception aus 'main' herausfällt. 233

11.  Guter Code, 2. Dan: Modularisierung. 235

       11.1. Programm, Bibliothek, Objektdatei. 235

       11.2. Bausteine. 236

       11.3. Trennen der Funktionalitäten. 237

       11.4. Ein modulares Beispielprojekt. 238

       11.5. Spezialthema: Unity-Builds. 249

TEIL II  Objektorientierte Programmierung und mehr. 251

12.  Von der Struktur zur Klasse. 253

       12.1. Initialisierung. 255

       12.2. Rückgabe eigener Typen. 256

       12.3. Methoden statt Funktionen. 257

       12.4. Das bessere 'drucke'. 260

       12.5. Eine Ausgabe wie jede andere. 262

       12.6. Methoden inline definieren. 263

       12.7. Implementierung und Definition trennen. 264

       12.8. Initialisierung per Konstruktor. 265

       12.9. Struktur oder Klasse?. 271

       12.10. Zwischenergebnis. 275

       12.11. Verwendung eigener Datentypen. 276

       12.12. Typinferenz mit 'auto'. 291

       12.13. Eigene Klassen in Standardcontainern. 294

13.  Namensräume und Qualifizierer. 297

       13.1. Der Namensraum 'std'. 297

       13.2. Anonymer Namensraum. 301

       13.3. 'static' macht lokal. 303

       13.4. 'static' teilt gern. 303

       13.5. 'static' macht dauerhaft. 306

       13.6. Zusammenfassung. 309

       13.7. Const. 310

       13.8. Flüchtig mit 'volatile'. 324

14.  Guter Code, 3. Dan: Testen. 327

       14.1. Arten des Tests. 327

       14.2. Frameworks. 335

       14.3. Boost.Test. 339

       14.4. Hilfsmakros für Assertions. 343

       14.5. Ein Beispielprojekt mit Unittests. 346

15.  Vererbung. 359

       15.1. Beziehungen. 360

       15.2. Vererbung in C++. 362

       15.3. Hat-ein versus ist-ein. 363

       15.4. Gemeinsamkeiten finden. 364

       15.5. Abgeleitete Typen erweitern. 366

       15.6. Methoden überschreiben. 367

       15.7. Wie Methoden funktionieren. 368

       15.8. Virtuelle Methoden. 370

       15.9. Konstruktoren in Klassenhierarchien. 372

       15.10. Typumwandlung in Klassenhierarchien. 373

       15.11. Wann virtuell?. 375

       15.12. Andere Designs zur Erweiterbarkeit. 376

16.  Der Lebenszyklus von Klassen. 379

       16.1. Erzeugung und Zerstörung. 380

       16.2. Temporary: kurzlebige Werte. 382

       16.3. Der Destruktor zum Konstruktor. 383

       16.4. Yoda-Bedingung. 387

       16.5. Konstruktion, Destruktion und Exceptions. 389

       16.6. Kopieren. 390

       16.7. Zuweisungsoperator. 393

       16.8. Streichen von Methoden. 396

       16.9. Verschiebeoperationen. 398

       16.10. Operatoren. 403

       16.11. Eigene Operatoren in einem Datentyp. 406

       16.12. Besondere Klassenformen. 411

17.  Guter Code, 4. Dan: Sicherheit, Qualität und Nachhaltigkeit. 415

       17.1. Die Nuller-Regel. 415

       17.2. RAII -- Resource Acquisition Is Initialization. 420

18.  Spezielles für Klassen. 429

       18.1. Darf alles sehen -- 'friend'-Klassen. 429

       18.2. non-public-Vererbung. 434

       18.3. Signatur-Klassen als Interfaces. 439

       18.4. Multiple Vererbung. 443

       18.5. Rautenförmige multiple Vererbung -- 'virtual' für Klassenhierarchien. 452

       18.6. Literale Datentypen -- 'constexpr' für Konstruktoren. 456

19.  Guter Code, 5. Dan: Klassisches objektorientiertes Design. 459

       19.1. Objekte in C++. 461

       19.2. Objektorientiert designen. 462

TEIL III  Fortgeschrittene Themen. 481

20.  Zeiger. 483

       20.1. Adressen. 484

       20.2. Zeiger. 485

       20.3. Gefahren von Aliasing. 487

       20.4. Heapspeicher und Stapelspeicher. 489

       20.5. Smarte Pointer. 492

       20.6. Rohe Zeiger. 501

       20.7. C-Arrays. 506

       20.8. Iteratoren. 511

       20.9. Zeiger als Iteratoren. 513

       20.10. Zeiger im Container. 513

       20.11. Die Ausnahme: wann das Wegräumen nicht nötig ist. 514

21.  Makros. 517

       21.1. Der Präprozessor. 518

       21.2. Vorsicht vor fehlenden Klammern. 521

       21.3. Vorsicht vor Mehrfachausführung. 522

       21.4. Typvariabilität von Makros. 523

       21.5. Zusammenfassung. 526

22.  Schnittstelle zu C. 527

       22.1. Mit Bibliotheken arbeiten. 528

       22.2. C-Header. 529

       22.3. C-Ressourcen. 532

       22.4. 'void'-Pointer. 532

       22.5. Daten lesen. 533

       22.6. Das Hauptprogramm. 534

       22.7. Zusammenfassung. 535

23.  Templates. 537

       23.1. Funktionstemplates. 538

       23.2. Funktionstemplates in der Standardbibliothek. 547

       23.3. Eine Klasse als Funktion. 551

       23.4. Templateklassen. 565

       23.5. Templates mit variabler Argumentanzahl. 576

       23.6. Eigene Literale. 580

TEIL IV  Die Standardbibliothek. 591

24.  Container. 593

       24.1. Grundlagen. 594

       24.2. Iteratoren-Grundlagen. 601

       24.3. Allokatoren: Speicherfragen. 605

       24.4. Container-Gemeinsamkeiten. 607

       24.5. Ein Überblick über die Standardcontainer-Klassen. 608

       24.6. Die sequenziellen Containerklassen. 612

       24.7. Assoziativ und geordnet. 647

       24.8. Nur assoziativ und nicht garantiert. 678

       24.9. Container-Adapter. 706

       24.10. Sonderfälle: 'string', 'basic string' und 'vector

C++

Beschreibung

Autoren/Hrsg.

Inhalt

Produkteigenschaften

Themen

Verlagspartner

Produktsortiment

Fachzeitschriften

Veranstaltungen

Site Breadcrumb

C++

Beschreibung

Autoren/Hrsg.

Inhalt

Produkteigenschaften

Themen