Vor Ort
Merkzettel Warenkorb
  • Produktbild: Notizen zu C++
  • Produktbild: Notizen zu C++

Notizen zu C++

Aus der Reihe Xpert.press

64,95 €

inkl. gesetzl. MwSt., Versandkostenfrei

Beschreibung

Produktdetails

Einband

Taschenbuch

Erscheinungsdatum

01.11.2012

Verlag

Springer Berlin

Seitenzahl

312

Maße (L/B/H)

23,5/15,5/1,8 cm

Gewicht

499 g

Auflage

Softcover reprint of the original 1st ed. 2004

Sprache

Deutsch

ISBN

978-3-642-62286-1

Beschreibung

Zitat

From the reviews: "The book is the result of 10 years of experience with C++. ... The book is divided into 26 chapters and provides information for senior programmers. ... The text is presented in a very condensed form. It provides information regarding software products, software architecture, CORBA and UML. ... the book might be a source of knowledge for C++ programmers." (P. Forbrig, Zentralblatt MATH, Vol. 1067, 2005)

Produktdetails

Einband

Taschenbuch

Erscheinungsdatum

01.11.2012

Verlag

Springer Berlin

Seitenzahl

312

Maße (L/B/H)

23,5/15,5/1,8 cm

Gewicht

499 g

Auflage

Softcover reprint of the original 1st ed. 2004

Sprache

Deutsch

ISBN

978-3-642-62286-1

Herstelleradresse

Springer-Verlag GmbH
Tiergartenstr. 17
69121 Heidelberg
DE

Email: ProductSafety@springernature.com

Ein neues Kapitel für Ihre Bücher

Ein neues Kapitel für Ihre Bücher

Schenken Sie Ihren alten Schätzen ein zweites Leben: Einfach Barcode scannen, Versandetikett ausdrucken, Bücher verschicken und Thalia Geschenkkarte erhalten.

Jetzt verkaufen
Jetzt verkaufen

Kundinnen und Kunden meinen

0 Bewertungen

Informationen zu Bewertungen

Zur Abgabe einer Bewertung ist eine Anmeldung im Konto notwendig. Die Authentizität der Bewertungen wird von uns nicht überprüft. Wir behalten uns vor, Bewertungstexte, die unseren Richtlinien widersprechen, entsprechend zu kürzen oder zu löschen.

Die Bewertungen sind nach Format, Anzahl Sterne und Datum sortiert.

Verfassen Sie die erste Bewertung zu diesem Artikel

Helfen Sie anderen Kund*innen durch Ihre Meinung

Kundinnen und Kunden meinen

0 Bewertungen filtern

Weitere Artikel finden Sie in
  • Produktbild: Notizen zu C++
  • Produktbild: Notizen zu C++
  • 1. Einordnung von C.- 2. Grundsätzlicher Aufbau eines Projektes.- 2.1 Pro Klasse eine *.h und eine *.cpp-Datei.- 2.2 Benennung von Verzeichnissen, Dateien und Klassen.- 2.3 Zentrale Header-Datei (Settings.h).- 2.4 Der Code muss ohne Warnungen bauen.- 2.5 Mehrere Schichten verwenden (horizontale Teilung).- 2.6 Client/Server-Modell verwenden (vertikale Teilung).- 2.7 Das Broker-Pattern (2-Tier-Architektur), CORBA, DCOM.- 2.7.1 Allgemeines.- 2.7.2 IDL-Compiler.- 2.8 CORBA mit TAO (The ACE ORB) von Douglas C. Schmidt.- 2.8.1 Allgemeines.- 2.8.2 Code-Beispiel mit GNU C++-Compiler unter LINUX.- 2.8.3 Code-Beispiel mit Visual C++ 6.0-Compiler unter WINDOWS-NT.- 2.9 UML (Unified Modeling Language).- 2.9.1 Allgemeines.- 2.9.2 Kardinalitäten nach UML.- 2.9.3 Frage nach den Klassen/Objekten.- 3. Wichtige Begriffe und Sprachelemente.- 3.1 namespace und using.- 3.2 Default-Konstruktor.- 3.3 Copy-Konstruktor.- 3.4 explicit-Konstruktor.- 3.5 Zuweisungs-Operator.- 3.6 Abstrakte Klasse (= abstrakte Basisklasse).- 3.7 Default-Argumente.- 3.8 Unspezifizierte Anzahl von Argumenten.- 3.9 l-value und r-value.- 3.10 Funktionszeiger.- 3.11 union.- 3.11.1 Allgemeines.- 3.11.2 Objekte unterschiedlichen Typs in eine Sequenz packen (list).- 3.11.3 Mehrere Datenstrukturen für dieselben Daten (hardwareabhängig).- 3.11.4 Bitfelder zum Abtasten von Byte-Streams (hardwareabhängig).- 3.11.5 Maske per Referenz anwenden.- 3.11.6 Test-Funktion zum Testen der Maschine auf little- bzw. big-endian.- 3.12 extern „C“ zum Abschalten der Namenszerstückelung.- 4. Grundsätzliche Regeln beim Programmieren.- 4.1 Include-Wächter verwenden.- 4.2 Kommentar // dem Kommentar /* */ vorziehen.- 4.3 Optimiere die Laufzeit immer gleich mit.- 4.3.1 Objekte erst dort definieren, wo sie gebraucht werden.- 4.3.2 Zuweisung an ein Objekt mit der Konstruktion verbinden.- 4.3.3 return, break und continue mit Geschick einsetzen.- 4.4 Laufvariable im Schleifenkopf definieren.- 4.5 Der Stack ist immer dem Heap (new/delete) vorzuziehen.- 4.6 protected nur bei Basisklassen.- 4.7 Keine Fehler beim Mischen von C- und C++-Code machen.- 4.8 Ungarische Notation verwenden.- 4.9 Eingebaute Datentypen nie hinter typedef verstecken.- 4.10 Implizite Typumwandlung ggf. abschalten.- 4.11 inline nur bei sehr einfachen nicht-virtuellen Funktionen.- 4.11.1 Allgemeines.- 4.11.2 Widerspruch „virtual und inline“: virtual dominiert inline.- 4.11.3 Basisklasse: Virtueller Destruktor als leere inline-Funktion.- 4.12 Falsche Benutzung einer Klasse ausschließen.- 4.12.1 Kopie eines Objektes verbieten.- 4.12.2 Konstruktion eines Objektes verbieten.- 4.13 Laufzeitschalter immer Compiler-Schaltern vorziehen.- 4.14 short statt bool als return-Wert bei Interface-Methoden.- 5. Strings.- 5.1 ASCII-Tabelle.- 5.2 string der STL.- 5.2.1 Allgemeines.- 5.2.2 String formatieren mit Hilfe von sprintf().- 5.2.3 Teil-Strings ersetzen mit string::replace() und string::find().- 5.2.4 Zeichen löschen mit string::erase() und einfügen mit string::insert().- 5.2.5 Umwandlung in Zahlen mit strtol() und der Methode string::c_str().- 5.2.6 Teil eines anderen Strings anhängen mit string::append().- 5.2.7 Konfigurationsdateien parsen mit string::compare() und string::copy().- 5.2.8 Worte sortieren mit set.- 5.2.9 Strings zuschneiden mit string::replace() und string::resize().- 5.3 string streams der STL.- 5.3.1 Allgemeines.- 5.3.2 Text mit istringstream nach enthaltenen Worten parsen.- 6. Zeitermittlung.- 6.1 Weltweit eindeutiger Timestamp (GMT), Jahr.- 6.2 Automatische Lokalisierung der Zeitdarstellung (strftime).- 7. Konstantes.- 7.1 const-Zeiger (C-Funktionen).- 7.2 const-Referenzen (C++-Funktionen).- 7.2.1 Allgemeines.- 7.2.2 STL-Container als const-Referenzen verlangen const_iterator.- 7.3 Read-Only-Member-Funktionen.- 7.3.1 Allgemeines.- 7.3.2 mutable-Member als interne Merker (Cache-Index) verwenden.- 7.3.3 Zeiger bei Read-Only-Member-Funktion besonders beachten.- 7.4 const-return-Wert.- 7.5 const statt #define verwenden.- 7.5.1 Globale Konstanten.- 7.5.2 Lokale Konstanten einer Klasse.- 7.6 const-inline-Template statt MAKRO (#define) verwenden.- 8. Globales (static-Member).- 8.1 static-Member.- 8.1.1 Allgemeines.- 8.1.2 Zugriff, ohne ein Objekt zu instanziieren.- 8.2 Vorsicht bei static-Variablen in nicht-statischen Methoden.- 8.3 static-Variable in static-Methode statt globaler Variable.- 8.4 Lokale statische Arrays durch Main-Thread instanziieren.- 8.5 Globale Funktionen: Nutze virtuelle Argument-Methoden.- 9. Referenz statt Zeiger (Zeiger für C-Interface).- 10. Funktionen, Argumente und return-Werte.- 10.1 Argumente sollten immer Referenzen sein.- 10.1.1 const-Referenz statt Wert-Übergabe (Slicing-Problem).- 10.1.2 Referenz statt Zeiger.- 10.2 Argumente: Default-Parameter vs. überladene Funktion.- 10.3 Überladen innerhalb einer Klasse vs. über Klasse hinweg.- 10.3.1 Allgemeines.- 10.3.2 Nie Zeiger-Argument mit Wert-Argument überladen.- 10.4 return: Referenz auf *this vs. Wertrückgabe.- 10.4.1 Lokal erzeugtes Objekt zurückliefern: Rückgabe eines Wertes.- 10.4.2 Objekt der Methode zurückliefern: Referenz auf *this.- 10.4.3 Keine Zeiger/Referenzen auf private-Daten zurückliefern.- 10.5 return-Wert nie an referenzierendes Argument übergeben.- 11. Smart-Pointer.- 11.1 Allgemeines.- 11.2 Smart-Pointer für die Speicher-Verwaltung.- 11.2.1 Eigenschaften des Smart-Pointers für die Speicherverwaltung.- 11.2.2 Was zu beachten ist.- 11.2.3 Code-Beispiel.- 11.2.4 Smart-Pointer immer per Referenz an eine Funktion übergeben.- 11.2.5 Empfehlungen.- 11.3 Smart-Pointer für andere Zwecke.- 12. new/delete.- 12.1 Allgemeines zu new.- 12.2 Allgemeines zu delete.- 12.3 Beispiel für new/delete.- 12.4 Allgemeines zu new[]/delete.- 12.4.1 new.- 12.4.2 delete.- 12.5 Mit Heap-Speicher arbeiten.- 12.6 Heap-Speicher als Shared Memory.- 12.7 new/delete statt malloc/free.- 12.8 Zusammenspiel von Allokierung und Freigabe.- 12.9 Eigener new-Handler statt Out-Of-Memory-Exception.- 12.10 Heap-Speicherung erzwingen/verbieten.- 12.10.1 Heap-Speicherung erzwingen (protected-Destruktor).- 12.10.2 Heap-Speicherung verbieten (private operator new).- 13. Statische, Heap- und Stack-Objekte.- 13.1 Die 3 Speicher-Arten.- 13.2 Statische Objekte (MyClass::Method()).- 13.3 Heap-Objekte (pObj->Method()).- 13.4 Stack-Objekte (Obj.Method()).- 14. Programmierung einer Klasse.- 14.1 Allgemeines.- 14.1.1 Fragen, die beim Entwurf einer Klasse beantwortet werden sollten.- 14.1.2 Die wesentlichen Methoden einer Klasse sind zu implementieren.- 14.1.3 Durch den Compiler automatisch generierte Methoden beachten.- 14.1.4 inline-Funktionen ggf. hinter die Deklaration schreiben.- 14.1.5 Nie public-Daten verwenden.- 14.1.6 Mehrdeutigkeiten (ambigious) erkennen.- 14.2 Der Konstruktor.- 14.2.1 Kein new im Konstruktor / Initialisierungslisten für Member.- 14.2.2 Keine virtuellen Methoden im Konstruktor aufrufen.- 14.2.3 Arrays mit memset() initialisieren.- 14.3 Der Destruktor.- 14.3.1 Generalisierung (“is-a”): Basisklasse soll virtuellen Destruktor haben.- 14.4 Zuweisung per operator=().- 14.4.1 Keine Zuweisung an sich selbst.- 14.4.2 Referenz auf *this zurückliefern.- 14.4.3 Alle Member-Variablen belegen.- 14.5 Indizierter Zugriff per operator[]().- 14.6 Virtuelle Clone()-Funktion: Heap-Kopie über pBase.- 14.7 Objektanzahl über private-Konstruktor kontrollieren.- 14.7.1 Objekte über eine friend-Klasse (Objekt-Manager) erzeugen.- 14.7.2 Objekte über eine statische Create()-Funktion erzeugen.- 14.7.3 Genau 1 Objekt erzeugen (Code und/oder Tabelle).- 14.8 Klassen neu verpacken mittels Wrapper-Klasse.- 15. Richtiges Vererbungs-Konzept.- 15.1 Allgemeines.- 15.1.1 Nie von (nicht-abstrakten) Klassen ohne virtuellen Destruktor erben.- 15.1.2 Nie den Copy-Konstruktor-Aufruf der Basisklasse vergessen.- 15.1.3 Statischer/dynamischer Typ und statische/dynamische Bindung.- 15.1.4 Nie die Default-Parameter virtueller Funktionen überschreiben.- 15.1.5 public-, protected- und private-Vererbung gezielt verwenden.- 15.1.6 Rein virtuell / virtuell / nicht-virtuell.- 15.1.7 Rein virtuelle Methoden, wenn keine generalisierte Implem. möglich.- 15.2 Spezialisierung durch public-Vererbung (“is a”).- 15.3 Code-Sharing durch private-Vererbung (“contains”).- 15.4 Composition statt multiple inheritance.- 15.5 Schnittstellen (AbstractMixinBaseClass) public dazuerben.- 15.6 Abstrakte Basisklasse vs. Template.- 15.7 Verknüpfung konkreter Klassen: abstrakte Basisklasse.- 15.8 Erben aus mehreren Basisklassen vermeiden.- 15.8.1 Expliziter Zugriff (oder using).- 15.8.2 Virtuelle Vererbung (Diamant-Struktur).- 15.9 Zuweisungen nur zwischen gleichen Child-Typen zulassen.- 16. Nutzer einer Klasse von Änderungen entkoppeln.- 16.1 Allgemeines.- 16.2 Header-Dateien: Forward-Deklaration statt #include.- 16.3 Delegation bzw. Aggregation.- 16.4 Objekt-Factory-Klasse und Protokoll-Klasse.- 17. Code kapseln.- 17.1 Beliebig viele Kopien erlaubt: Funktions-Obj. (operator()).- 17.2 Nur 1 Kopie erlaubt: Statische Obj. (MyClass::Method()).- 18. Operatoren.- 18.1 Definition von Operatoren.- 18.2 Binäre Operatoren effektiv implementieren.- 18.3 Unäre Operatoren bevorzugt verwenden.- 18.4 Kommutativität: Globale bin. Operatoren implementieren.- 18.5 Operator-Vorrang (Precedence).- 18.6 Präfix- und Postfix-Operator.- 18.6.1 Allgemeines.- 18.6.2 Wartungsfreundlichkeit erhöhen durch ++(*this) im Postfix-Operator.- 18.6.3 Präfix(++Obj) ist Postfix(Obj++) vorzuziehen.- 18.7 Der Komma-Operator.- 19. Datentypen und Casting.- 19.1 Datentypen.- 19.2 Polymorphismus: vfptr und vftable.- 19.3 RTTI (type_info) und typeid bei polymorphen Objekten.- 19.4 dynamic_cast: Sicherer cast von Zeigern oder Referenzen.- 19.4.1 Allgemeines.- 19.4.2 dynamic_cast zur Argumentprüfung bei Basisklassen-Zeiger/Referenz.- 19.5 const_cast.- 19.6 reinterpret_cast (!nicht portabel!) und Funktions-Vektoren.- 19.7 STL: Min- und Max-Werte zu einem Datentyp.- 20. In Bibliotheken Exceptions werfen.- 20.1 Allgemeines.- 20.2 Exceptions per Referenz fangen.- 20.3 Kopien beim Weiterwerfen vermeiden.- 20.4 Beispiel für Exception-Handling.- 20.5 Exception-Spezifikation.- 20.5.1 Allgemeines.- 20.5.2 Spezifikationswidrige Exceptions abfangen: set_unexpected.- 20.5.3 Compilerunabhängiges Vorgehen.- 21. Die STL (Standard Template Library).- 21.1 Allgemeines.- 21.2 Nutzung der STL von STLport.- 21.2.1 Allgemeines.- 21.2.2 STLport mit GNU unter Linux.- 21.2.3 STLport mit Visual C++ unter Windows.- 21.3 STL-Header-Dateien.- 21.3.1 Aufbau: Die Endung “.h” fehlt.- 21.3.2 Nutzung: “using namespace std”.- 21.4 Wichtige STL-Member-Variablen und Methoden.- 21.5 Generierung von Sequenzen über STL-Algorithmen.- 21.5.1 back_inserter().- 21.5.2 Schnittmenge (set_intersection).- 21.5.3 Schnittmenge ausschließen (set_symmetric_difference).- 21.5.4 Sequenz ausschließen (set_difference).- 21.5.5 Vereinigungsmenge bilden (set_union).- 21.5.6 Liste an eine andere Liste anhängen (list::insert).- 21.6 Wichtige Regeln.- 21.6.1 Einbinden der STL.- 21.6.2 Die benötigten Operatoren implementieren.- 21.6.3 Iterator: ++it statt it++ benutzen.- 21.6.4 Löschen nach find(): Immer über Iterator (it) statt über den Wert (*it).- 21.6.5 map: Nie indizierten Zugriff [ ] nach find() durchführen.- 21.7 Beispiele für die Verwendung der Container.- 21.7.1 list: Auflistung von Objekten mit möglichen Mehrfachvorkommnissen.- 21.7.2 set: Aufsteigend sortierte Menge von Objekten (unique).- 21.7.3 map: Zuordnung von Objekten zu eindeutigen Handles.- 21.7.4 map: Mehrdimensionaler Schlüssel.- 21.7.5 vector: Schneller indizierter Zugriff.- 21.7.6 pair und make_pair(): Wertepaare abspeichern.- 21.8 hash_map.- 21.8.1 hash_map für Nutzer von Visual C.- 21.8.2 Prinzip von hash_map.- 21.8.3 Nutzung von hash_map der STL.- 21.9 Lokalisierung mit der STL (streams und locales).- 22. Arten von Templates.- 22.1 Class-Template.- 22.2 Function-Template.- 22.2.1 Global Function Template.- 22.2.2 Member Function Template.- 22.3 Explizite Instanziierung von Templates.- 23. Proxy-Klassen.- 23.1 Allgemeines.- 23.2 Schreiben/Lesen beim indizierten Zugriff unterscheiden.- 24. Datenbank-Zugriff.- 24.1 Zugriff auf objektorientierte Datenbanken.- 24.2 Zugriff auf relationale Datenbanken.- 24.3 Zugriff auf hierarchische Datenbanken.- 25. Aktion nach Kollision über Objekttyp steuern.- 26. 80/20-Regel und Performance-Optimierung.- 26.1 Allgemeines.- 26.2 Zeit-Optimierungen.- 26.2.1 return so früh wie möglich.- 26.2.2 Präfix-Operator statt Postfix-Operator.- 26.2.3 Unäre Operatoren den binären Operatoren vorziehen.- 26.2.4 Keine Konstruktion/Destruktion in Schleifen.- 26.2.5 hash_map statt map, falls keine Sortierung benötigt wird.- 26.2.6 Lokaler Cache um Berechnungen/Datenermittlungen zu sparen.- 26.2.7 Löschen nach find() immer direkt über den Iterator.- 26.2.8 map: nie indizierten Zugriff [ ] nach find() durchführen.- 26.2.9 Unsichtbare temporäre Objekte vermeiden.- 26.2.10 Berechnungen erst dann, wenn das Ergebnis gebraucht wird.- 26.2.11 Datenermittlung erst dann, wenn die Daten gebraucht werden.- 26.2.12 Große Anzahl kleiner Objekte blockweise lesen (Prefetching).- 26.2.13 Kein unnötiges Speichern in die Datenbank.- 26.2.14 SQL-SELECT-Statements effektiv aufbauen: DB-Server filtern lassen.- 26.3 Speicher-Optimierungen.- 26.3.1 Sharing von Code und/oder Tabellen mittels statischem Objekt.- 26.3.2 Sharing von Code und/oder Tabellen mittels Heap-Objekt.- 26.3.3 Nach Kopie die Daten bis zum Schreibzugriff sharen (Copy-On-Write).- 26.3.4 Object-Pooling.