Will - C++ - 9783836275934

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

C++

Das umfassende Handbuch zu Modern C++. Über 1.000 Seiten Profiwissen, aktuell zum Standard C++20

Medium: Buch

ISBN: 978-3-8362-7593-4

Verlag: Rheinwerk Verlag GmbH

Erscheinungstermin: 28.07.2020

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

sofort versandfertig, Lieferfrist: 1-3 Werktage

Vorwort. 23

  Vorwort zur 1. Auflage. 25

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. 40

       2.5. Die Kommandozeile unter Ubuntu. 42

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

       2.7. Das Beispielprogramm beschleunigen. 48

  3.  C++ für Umsteiger. 49

  4.  Die Grundbausteine von C++. 57

       4.1. Kommentare. 60

       4.2. Die 'include'-Direktive. 60

       4.3. Die Standardbibliothek. 60

       4.4. Die Funktion 'main()'. 61

       4.5. Typen. 61

       4.6. Variablen. 62

       4.7. Initialisierung. 62

       4.8. Ausgabe auf der Konsole. 63

       4.9. Anweisungen. 63

       4.10. Ohne Eile erklärt. 65

       4.11. Operatoren. 91

       4.12. Eingebaute Datentypen. 105

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

       5.1. Kommentare. 144

       5.2. Dokumentation. 144

       5.3. Einrückungen und Zeilenlänge. 145

       5.4. Zeilen pro Funktion und Datei. 146

       5.5. Klammern und Leerzeichen. 147

       5.6. Namen. 148

  6.  Höhere Datentypen. 151

       6.1. Der Zeichenkettentyp 'string'. 152

       6.2. Streams. 158

       6.3. Behälter und Zeiger. 164

       6.4. Die einfachen Sequenzcontainer. 166

       6.5. Algorithmen. 171

       6.6. Zeiger und C-Arrays. 172

  7.  Funktionen. 173

       7.1. Deklaration und Definition einer Funktion. 174

       7.2. Funktionstyp. 175

       7.3. Funktionen verwenden. 175

       7.4. Eine Funktion definieren. 177

       7.5. Mehr zu Parametern. 178

       7.6. Funktionskörper. 182

       7.7. Parameter umwandeln. 184

       7.8. Funktionen überladen. 186

       7.9. Default-Parameter. 188

       7.10. Beliebig viele Argumente. 190

       7.11. Alternative Schreibweise zur Funktionsdeklaration. 190

       7.12. Spezialitäten. 191

  8.  Anweisungen im Detail. 195

       8.1. Der Anweisungsblock. 198

       8.2. Die leere Anweisung. 200

       8.3. Deklarationsanweisung. 201

       8.4. Die Ausdrucksanweisung. 203

       8.5. Die 'if'-Anweisung. 204

       8.6. Die 'while'-Schleife. 208

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

       8.8. Die 'for'-Schleife. 211

       8.9. Die bereichsbasierte 'for'-Schleife. 213

       8.10. Die 'switch'-Verzweigung. 215

       8.11. Die 'break'-Anweisung. 219

       8.12. Die 'continue'-Anweisung. 220

       8.13. Die 'return'-Anweisung. 221

       8.14. Die 'goto'-Anweisung. 222

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

       8.16. Zusammenfassung. 225

  9.  Ausdrücke im Detail. 227

       9.1. Berechnungen und Seiteneffekte. 228

       9.2. Arten von Ausdrücken. 229

       9.3. Literale. 230

       9.4. Bezeichner. 231

       9.5. Klammern. 231

       9.6. Funktionsaufruf und Indexzugriff. 232

       9.7. Zuweisung. 232

       9.8. Typumwandlung. 234

10.  Fehlerbehandlung. 237

       10.1. Fehlerbehandlung mit Fehlercodes. 239

       10.2. Was ist eine Ausnahme?. 242

       10.3. Kleinere Fehlerbehandlungen. 245

       10.4. Weiterwerfen -- 'rethrow'. 245

       10.5. Die Reihenfolge im 'catch'. 246

       10.6. Typen für Exceptions. 248

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

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

       11.1. Programm, Bibliothek, Objektdatei. 251

       11.2. Bausteine. 252

       11.3. Trennen der Funktionalitäten. 253

       11.4. Ein modulares Beispielprojekt. 255

       11.5. Spezialthema: Unity-Builds. 265

TEIL II  Objektorientierte Programmierung und mehr. 267

12.  Von der Struktur zur Klasse. 269

       12.1. Initialisierung. 271

       12.2. Rückgabe eigener Typen. 272

       12.3. Methoden statt Funktionen. 273

       12.4. Das bessere 'drucke'. 276

       12.5. Eine Ausgabe wie jede andere. 278

       12.6. Methoden inline definieren. 279

       12.7. Implementierung und Definition trennen. 280

       12.8. Initialisierung per Konstruktor. 281

       12.9. Struktur oder Klasse?. 288

       12.10. Zwischenergebnis. 292

       12.11. Verwendung eigener Datentypen. 293

       12.12. Typinferenz mit 'auto'. 308

       12.13. Eigene Klassen in Standardcontainern. 311

13.  Namensräume und Qualifizierer. 315

       13.1. Der Namensraum 'std'. 315

       13.2. Anonymer Namensraum. 319

       13.3. 'static' macht lokal. 321

       13.4. 'static' teilt gern. 322

       13.5. 'static' macht dauerhaft. 325

       13.6. Zusammenfassung. 328

       13.7. 'const'. 329

       13.8. Flüchtig mit 'volatile'. 344

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

       14.1. Arten des Tests. 347

       14.2. Frameworks. 355

       14.3. Boost.Test. 359

       14.4. Hilfsmakros für Assertions. 363

       14.5. Ein Beispielprojekt mit Unittests. 366

15.  Vererbung. 379

       15.1. Beziehungen. 380

       15.2. Vererbung in C++. 383

       15.3. Hat-ein versus ist-ein. 384

       15.4. Gemeinsamkeiten finden. 384

       15.5. Abgeleitete Typen erweitern. 387

       15.6. Methoden überschreiben. 388

       15.7. Wie Methoden funktionieren. 389

       15.8. Virtuelle Methoden. 390

       15.9. Konstruktoren in Klassenhierarchien. 392

       15.10. Typumwandlung in Klassenhierarchien. 394

       15.11. Wann virtuell?. 396

       15.12. Andere Designs zur Erweiterbarkeit. 397

16.  Der Lebenszyklus von Klassen. 399

       16.1. Erzeugung und Zerstörung. 400

       16.2. Temporary: kurzlebige Werte. 402

       16.3. Der Destruktor zum Konstruktor. 404

       16.4. Yoda-Bedingung. 408

       16.5. Konstruktion, Destruktion und Exceptions. 410

       16.6. Kopieren. 411

       16.7. Zuweisungsoperator. 414

       16.8. Streichen von Methoden. 417

       16.9. Verschiebeoperationen. 419

       16.10. Operatoren. 424

       16.11. Eigene Operatoren in einem Datentyp. 427

       16.12. Besondere Klassenformen. 432

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

       17.1. Die Nullerregel. 437

       17.2. RAII -- Resource Acquisition Is Initialization. 443

18.  Spezielles für Klassen. 453

       18.1. Dürfen alles sehen -- 'friend'-Klassen. 453

       18.2. Non-public-Vererbung. 457

       18.3. Signaturklassen als Interfaces. 463

       18.4. Multiple Vererbung. 467

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

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

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

       19.1. Objekte in C++. 485

       19.2. Objektorientiert designen. 486

TEIL III  Fortgeschrittene Themen. 505

20.  Zeiger. 507

       20.1. Adressen. 508

       20.2. Zeiger. 509

       20.3. Gefahren von Aliasing. 511

       20.4. Heapspeicher und Stapelspeicher. 513

       20.5. Smarte Pointer. 516

       20.6. Rohe Zeiger. 526

       20.7. C-Arrays. 530

       20.8. Iteratoren. 536

       20.9. Zeiger als Iteratoren. 538

       20.10. Zeiger im Container. 538

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

21.  Makros. 541

       21.1. Der Präprozessor. 542

       21.2. Vorsicht vor fehlenden Klammern. 546

       21.3. Vorsicht vor Mehrfachausführung. 547

       21.4. Typvariabilität von Makros. 548

       21.5. Zusammenfassung. 551

22.  Schnittstelle zu C. 553

       22.1. Mit Bibliotheken arbeiten. 554

       22.2. C-Header. 555

       22.3. C-Ressourcen. 558

       22.4. 'void'-Pointer. 559

       22.5. Daten lesen. 559

       22.6. Das Hauptprogramm. 561

       22.7. Zusammenfassung. 561

23.  Templates. 563

       23.1. Funktionstemplates. 564

       23.2. Funktionstemplates in der Standardbibliothek. 574

       23.3. Eine Klasse als Funktion. 578

       23.4. Templateklassen. 593

       23.5. Templates mit variabler Argumentanzahl. 607

       23.6. Eigene Literale. 611

TEIL IV  Die Standardbibliothek. 621

24.  Container. 623

       24.1. Grundlagen. 624

       24.2. Iteratoren-Grundlagen. 631

       24.3. Allokatoren: Speicherfragen. 635

       24.4. Containergemeinsamkeiten. 638

       24.5. Ein Überblick über die Standardcontainerklassen. 639

       24.6. Die sequenziellen Containerklassen. 643

       24.7. Assoziativ und geordnet. 680

       24.8. Nur assoziativ und nicht garantiert. 712

       24.9. Containeradapter. 742

       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