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.