Warenkorb
€ 0,00 0 Buch dabei,
portofrei
Notizen zu C++ als Buch
PORTO-
FREI

Notizen zu C++

'Xpert. press'. Auflage 2004. Book.
Buch (gebunden)
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 … weiterlesen
Dieses Buch ist auch verfügbar als:
Buch

76,99*

inkl. MwSt.
Portofrei
Lieferbar innerhalb von zwei bis drei Werktagen
Notizen zu C++ als Buch

Produktdetails

Titel: Notizen zu C++
Autor/en: Peter Thömmes

ISBN: 3540010580
EAN: 9783540010586
'Xpert. press'.
Auflage 2004.
Book.
Springer Berlin Heidelberg

9. Oktober 2003 - gebunden - 328 Seiten

Beschreibung

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.

Inhaltsverzeichnis

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.

Portrait

Peter Thömmes begann 1981 eine Ausbildung zum Elektroniker und programmierte zum ersten Mal einen Prozessor in Hex-Code und Assembler Mnemo-Code. Der künftige Berufsweg führte ihn anschließend in die verschiedensten Gebiete der Programmierung. Nach seinem Studium der Elektrotechnik 1992 an der Fachhochschule Saarbrücken studierte der Autor Elektrotechnik an der Universität des Saarlandes in Saarbrücken, wo er gleichzeitig am DFKI (Deutsches Forschungszentrum für künstliche Intelligenz) als wissenschaftlicher Mitarbeiter tätig war und ISDN-Anwendungen in C++ programmierte. Nach dem Studium entwickelte Peter Thömmes Mikrokontrollerschaltungen und Betriebssysteme (Assembler/C) sowie Steuerprogramme (C++) bei Fa. Siebert Industrieelektronik GmbH. Anschließend wechselte er in die Geschäftsprozess-Welt der IDS Scheer AG, wo er Kernelkomponenten des ARIS Toolset entwickelte (C++). Seit 2001 ist Herr Thömmes als Projekt Manager im Bereich Communication Software Engineering bei Fa. SES ASTRA S.A. in Luxembourg tätig.

Pressestimmen

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)
Servicehotline
089 - 70 80 99 47

Mo. - Fr. 8.00 - 20.00 Uhr
Sa. 10.00 - 20.00 Uhr
Filialhotline
089 - 30 75 75 75

Mo. - Sa. 9.00 - 20.00 Uhr
Bleiben Sie in Kontakt:
Sicher & bequem bezahlen:
akzeptierte Zahlungsarten: Überweisung, offene Rechnung,
Visa, Master Card, American Express, Paypal
Zustellung durch:
* Alle Preise verstehen sich inkl. der gesetzlichen MwSt. Informationen über den Versand und anfallende Versandkosten finden Sie hier.
** Deutschsprachige eBooks und Bücher dürfen aufgrund der in Deutschland geltenden Buchpreisbindung und/oder Vorgaben von Verlagen nicht rabattiert werden. Soweit von uns deutschsprachige eBooks und Bücher günstiger angezeigt werden, wurde bei diesen kürzlich von den Verlagen der Preis gesenkt oder die Buchpreisbindung wurde für diese Titel inzwischen aufgehoben. Angaben zu Preisnachlässen beziehen sich auf den dargestellten Vergleichspreis.