76,99
versandkostenfrei*

Preis in Euro, inkl. MwSt.
Versandfertig in 3-5 Tagen
Bequeme Ratenzahlung möglich!
ab 3,75 monatlich
0 °P sammeln

    Gebundenes Buch

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…mehr

Produktbeschreibung
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.
  • Produktdetails
  • Verlag: Springer Berlin / Springer Berlin Heidelberg
  • 2004
  • Seitenzahl: 328
  • Erscheinungstermin: 9. Oktober 2003
  • Deutsch
  • Abmessung: 235mm x 155mm x 23mm
  • Gewicht: 654g
  • ISBN-13: 9783540010586
  • ISBN-10: 3540010580
  • Artikelnr.: 12072071
Autorenporträt
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.
Inhaltsangabe
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.

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
Rezensionen
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)