Notizen zu C ++ (Xpert.press) (2004. XIII, 312 S. 24 cm)

個数:

Notizen zu C ++ (Xpert.press) (2004. XIII, 312 S. 24 cm)

  • 在庫がございません。海外の書籍取次会社を通じて出版社等からお取り寄せいたします。
    通常6~9週間ほどで発送の見込みですが、商品によってはさらに時間がかかることもございます。
    重要ご説明事項
    1. 納期遅延や、ご入手不能となる場合がございます。
    2. 複数冊ご注文の場合、分割発送となる場合がございます。
    3. 美品のご指定は承りかねます。

  • 提携先の海外書籍取次会社に在庫がございます。通常3週間で発送いたします。
    重要ご説明事項
    1. 納期遅延や、ご入手不能となる場合が若干ございます。
    2. 複数冊ご注文の場合、分割発送となる場合がございます。
    3. 美品のご指定は承りかねます。
  • 【入荷遅延について】
    世界情勢の影響により、海外からお取り寄せとなる洋書・洋古書の入荷が、表示している標準的な納期よりも遅延する場合がございます。
    おそれいりますが、あらかじめご了承くださいますようお願い申し上げます。
  • ◆画像の表紙や帯等は実物とは異なる場合があります。
  • ◆ウェブストアでの洋書販売価格は、弊社店舗等での販売価格とは異なります。
    また、洋書販売価格は、ご注文確定時点での日本円価格となります。
    ご注文確定後に、同じ洋書の販売価格が変動しても、それは反映されません。
  • 製本 Hardcover:ハードカバー版
  • 商品コード 9783540010586

Full Description

Die "Notizen zu C++" richten sich an den erfahrenen C++ Software-Entwickler. Sie erläutern für zahlreiche komplexe Problemstellungen, die sich dem Software-Entwickler bei der täglichen Arbeit stellen, wie die optimale Lösung aussieht. Dazu wird in präziser und kompakter Form erklärt, warum der aufgezeigte Weg optimal ist. Die jeweils vorgeschlagene Lösung wird an Code-Beispielen fundiert umgesetzt. Oft münden die Schlußfolgerungen in einem prägnanten Merksatz, der dann auch die Überschrift des entsprechenden Kapitels bildet. Der Aufbau dieses Werkes ist den Bedürfnissen von Software-Entwicklern optimal angepaßt. Der Autor ist seit vielen Jahren in der systemnahen C++ Software-Entwicklung tätig und weiß, daß ein gutes Code-Beispiel dem Entwickler mehr sagt als 1000 Worte.

Contents

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.