C++-Entwicklung mit Linux

Eine Einführung in die Sprache und die wichtigsten Werkzeuge
von GCC und XEmacs bis Eclipse

© 2004 by Thomas Wieland. Einige Rechte vorbehalten.





Überblick

Programmieren unter Linux

Grundlagen der objektorientierten Programmierung in C++

Programmieren mit C++

Fortgeschrittenes C++

Editoren für die Programmierung

Werkzeuge für die Softwareentwicklung

Integrierte Entwicklungsumgebungen

Literaturverzeichnis

Index

Inhaltsverzeichnis

1 Programmieren unter Linux
 1.1 Das Unix-Betriebssystem
  1.1.1 Die Unix-Familie
  1.1.2 Besondere Eigenschaften von Unix
  1.1.3 Die Werkzeug-Philosophie
 1.2 Linux
 1.3 Kommerzielle und freie Software
  1.3.1 Das GNU-Projekt
  1.3.2 Die GNU General Public License
  1.3.3 Andere Open-Source-Ansätze
  1.3.4 Vorteile von Open Source
  1.3.5 Motivation für Open Source
  1.3.6 Fazit
 1.4 Programmentwicklung in Unix
  1.4.1 Wichtige Begriffe
  1.4.2 Systemdateien zur Entwicklung
 1.5 Übungsfragen
2 Grundlagen der objektorientierten Programmierung in C++
 2.1 Grundideen
  2.1.1 Beherrschung der Komplexität
  2.1.2 Rückblick auf strukturiertes Programmieren
  2.1.3 Objekte
  2.1.4 Klassen
  2.1.5 Methoden und Prozessabstraktion
  2.1.6 Datenabstraktion
  2.1.7 Zusammenfassung
  2.1.8 Übungsaufgaben
 2.2 Die C++-Programmiersprache
  2.2.1 Historisches
  2.2.2 C++ und C
  2.2.3 C++ und Linux
  2.2.4 Das erste C++-Programm
  2.2.5 Datentypen und Typumwandlung
  2.2.6 Operatoren
  2.2.7 Ausdrücke
  2.2.8 Zusammenfassung
  2.2.9 Übungsaufgaben
 2.3 Umgang mit dem GNU-C++-Compiler
  2.3.1 Installation
  2.3.2 Aufruf und Optionen
  2.3.3 Name für die ausführbare Datei
  2.3.4 Debug-Informationen
  2.3.5 Fehler und Warnungen
  2.3.6 Kompilierung zur Objektdatei
  2.3.7 Pfade zu Header-Dateien
  2.3.8 Vorkompilierte Header-Dateien
  2.3.9 Bibliotheken
  2.3.10 Optimierung
  2.3.11 Info-Seiten und Texteditoren
  2.3.12 Zusammenfassung
  2.3.13 Übungsaufgaben
 2.4 Klassen und Objekte
  2.4.1 Klassendeklaration und -definition
  2.4.2 Objekte von Klassen
  2.4.3 Zugriffsbeschränkungen
  2.4.4 Freunde
  2.4.5 Zusammenfassung
  2.4.6 Übungsaufgaben
 2.5 Namensräume
  2.5.1 Definition
  2.5.2 Zugriff auf Bezeichner in Namensräumen
  2.5.3 Zusammenfassung mehrerer Namensräume
  2.5.4 Verschachtelte Namensräume
  2.5.5 Zusammenfassung
  2.5.6 Übungsaufgaben
 2.6 Funktionen und Methoden
  2.6.1 Funktionen in C++
  2.6.2 Der Prototyp
  2.6.3 Überladen von Funktionen
  2.6.4 Überladen von main()
  2.6.5 Vorgabewerte für Parameter
  2.6.6 Referenzen und Parameterübergabe
  2.6.7 Zugriffsroutinen
  2.6.8 Inline-Funktionen
  2.6.9 Zusammenfassung
  2.6.10 Übungsaufgaben
 2.7 Konstruktoren und Destruktoren
  2.7.1 Überblick über Konstruktoren
  2.7.2 Standardkonstruktor
  2.7.3 Allgemeine Konstruktoren
  2.7.4 Initialisierung mit Listen
  2.7.5 Kopierkonstruktor
  2.7.6 Typumwandlungskonstruktor
  2.7.7 Destruktoren
  2.7.8 Beispiel: Benutzerinformationen
  2.7.9 Zusammenfassung
  2.7.10 Übungsaufgaben
 2.8 Vererbung und Polymorphismus
  2.8.1 Basisklassen und abgeleitete Klassen
  2.8.2 Vererbung in C++
  2.8.3 Erzeugung von Unterklassenobjekten
  2.8.4 Zugriffsbeschränkungen
  2.8.5 Mehrfachvererbung
  2.8.6 Polymorphismus
  2.8.7 Rein virtuelle Funktionen und abstrakte Klassen
  2.8.8 Zusammenfassung
  2.8.9 Übungsaufgaben
3 Programmieren mit C++
 3.1 Basiselemente
  3.1.1 Bedingungen
  3.1.2 Mehrfache Auswahl
  3.1.3 Schleifen
  3.1.4 Zusammenfassung
  3.1.5 Übungsaufgaben
 3.2 Dateien und Ströme
  3.2.1 Standardein- und -ausgabe
  3.2.2 Ein- und Ausgabe mit Dateien
  3.2.3 Positionierung des Dateizeigers
  3.2.4 Ausgabeformatierung
  3.2.5 Beispiel: Umrechnung Dollar - Euro
  3.2.6 Zusammenfassung
  3.2.7 Übungsaufgaben
 3.3 Felder, Zeiger und dynamische
Speicherverwaltung

  3.3.1 Felder (Arrays)
  3.3.2 Zeichenketten
  3.3.3 Zeiger
  3.3.4 Dynamische Speicherverwaltung
  3.3.5 Konstruktoren und Destruktoren
  3.3.6 Beispiel: Verkettete Listen
  3.3.7 Zusammenfassung
  3.3.8 Übungsaufgaben
 3.4 Die C-Bibliothek
  3.4.1 Umfang der C-Bibliothek
  3.4.2 Das man-Kommando
  3.4.3 Mathematische Standardfunktionen (cmath)
  3.4.4 Numerische Limits (climits und cfloat)
  3.4.5 Auswertung von Fehlern bei
Bibliotheksfunktionen (cerrno)

  3.4.6 Behandlung von Signalen (csignal)
  3.4.7 Allgemeine Utilities (cstdlib)
  3.4.8 Ein- und Ausgabefunktionen (cstdio)
  3.4.9 Zugriff auf und Manipulation von char-Strings (cstring)
  3.4.10 Zusammenfassung
  3.4.11 Übungsaufgaben
 3.5 Eigene Bibliotheken
  3.5.1 Statische Bibliotheken
  3.5.2 Beispiel: Zugriff auf Verzeichnisse
  3.5.3 Dynamische Bibliotheken (shared libraries)
  3.5.4 Zusammenfassung
  3.5.5 Übungsaufgaben
 3.6 Tipps und Konventionen
  3.6.1 Namenskonventionen
  3.6.2 Projektorganisation
  3.6.3 Programmierstil
  3.6.4 Sicheres Programmieren
  3.6.5 C++-Programmierstil
  3.6.6 Zusammenfassung
4 Fortgeschrittenes C++
 4.1 Templates
  4.1.1 Funktionstemplates
  4.1.2 Organisation des Quelltextes
  4.1.3 Klassentemplates
  4.1.4 Zusammenfassung
  4.1.5 Übungsaufgaben
 4.2 Die STL: die Containerklassen der
C++-Standardbibliothek

  4.2.1 Namenskonventionen
  4.2.2 Strings
  4.2.3 Container
  4.2.4 Iteratoren
  4.2.5 Algorithmen
  4.2.6 Zusammenfassung
  4.2.7 Übungsaufgaben
 4.3 Operatoren zur Typumwandlung
  4.3.1 Der static_cast-Operator
  4.3.2 Der dynamic_cast-Operator
  4.3.3 Der const_cast-Operator
  4.3.4 Der reinterpret_cast-Operator
  4.3.5 Zusammenfassung
  4.3.6 Übungsaufgaben
 4.4 Überladen von Operatoren
  4.4.1 Operatorfunktionen und -methoden
  4.4.2 Arten von Operatoren
  4.4.3 Der Indexoperator
  4.4.4 Der Inkrementoperator
  4.4.5 Der Zuweisungsoperator
  4.4.6 Vergleiche und mathematische Operatoren
  4.4.7 Operatoren als Freunde
  4.4.8 Ein- und Ausgabeoperator
  4.4.9 Typumwandlungsoperator
  4.4.10 Allgemeine Prinzipien
  4.4.11 Zusammenfassung
  4.4.12 Übungsaufgaben
 4.5 Ausnahmebehandlung (Exceptions)
  4.5.1 Behandlung von Fehlersituationen
  4.5.2 Exception Handling
  4.5.3 Allgemeine Syntax
  4.5.4 Auffangen der Ausnahmen
  4.5.5 Beispiel: Vektor
  4.5.6 Exceptions und die Standardbibliothek
  4.5.7 Tipps und Hinweise
  4.5.8 Zusammenfassung
  4.5.9 Übungsaufgaben
5 Editoren für die Programmierung
 5.1 vi improved
  5.1.1 Starten und Beenden
  5.1.2 Die Bearbeitungsmodi
  5.1.3 Bewegen des Cursors
  5.1.4 Text schreiben und löschen
  5.1.5 Suchen und Ersetzen
  5.1.6 Speichern und Laden
  5.1.7 Kopieren und Verschieben
  5.1.8 Weitere Befehle
  5.1.9 Zusammenfassung
 5.2 Der XEmacs-Editor
  5.2.1 Grundlegende Befehle
  5.2.2 Suchen und Ersetzen
  5.2.3 Ausschneiden, Kopieren und Einfügen
  5.2.4 Modi
  5.2.5 Fazit
 5.3 Weitere Editoren
6 Werkzeuge für die Softwareentwicklung
 6.1 Steuerung der Übersetzung mit
Make-Dateien

  6.1.1 Aufbau von Makefiles
  6.1.2 Arbeiten mit make
  6.1.3 Makros
  6.1.4 Eingebaute Regeln
  6.1.5 make für Fortgeschrittene
  6.1.6 Zusammenfassung
 6.2 Fehlersuche mit dem Debugger
  6.2.1 Theoretische Fehlerquellen
  6.2.2 Statusausgaben im Code
  6.2.3 Ein fehlerhaftes Programm
  6.2.4 Fehlersuche mit gdb
  6.2.5 Fehlervermeidung durch die Überprüfung von Vorbedingungen
  6.2.6 Zusammenfassung
 6.3 Versionskontrolle mit CVS
  6.3.1 Versionskontrolle mit Linux
  6.3.2 Vorgehensweise
  6.3.3 Versionsverwaltung mit CVS
  6.3.4 Zusammenfassung
7 Integrierte Entwicklungsumgebungen
 7.1 XEmacs als IDE
  7.1.1 Der Editor
  7.1.2 Start des Compilers
  7.1.3 Start des Programms und des Debuggers
  7.1.4 Versionsverwaltung mit XEmacs
  7.1.5 Dateivergleich mit Ediff
  7.1.6 Zusammenfassung
 7.2 KDevelop
  7.2.1 Überblick
  7.2.2 Die KDevelop-Entwicklungsumgebung
  7.2.3 Mit Konsolenanwendungen arbeiten
  7.2.4 KDE-Anwendungen mit KDevelop entwickeln
  7.2.5 Zusammenfassung
  7.2.6 Übungsaufgaben
 7.3 Eclipse
  7.3.1 Die Idee von Eclipse
  7.3.2 Die Eclipse-Plattform unter der Haube
  7.3.3 Eclipse als IDE
  7.3.4 Ein Beispielprogramm
  7.3.5 Anbindung von CVS
  7.3.6 Zusammenfassung
Literaturverzeichnis

Vorwort zur dritten Auflage

Programmierbücher haben meist nur eine begrenzte "Haltbarkeit". Sie beschreiben eine Technologie oder ein Werkzeug, die schnell wieder durch andere ersetzt werden. In diesem Fall trifft das (zum Glück) nur zum Teil zu. Die Programmiersprache C++ blieb seit der letzten Auflage weitgehend gleich und selbst der GCC-Compiler änderte sich nur in Teilaspekten, die bereits über die in einem solchen Einsteiger-Buch sinnvolle Detailtiefe hinausgehen.

Andere Werkzeuge haben dagegen in der Zwischenzeit eine stärkere Veränderung durchgemacht. Daher war im hinteren Teil des Buches mancherlei Anpassung nötig. Zudem wurde das Buch deutlich schlanker und ist damit nun hoffentlich auch als Lehr- und Lernbuch besser geeignet. Dazu soll auch die deutlich größere Zahl an Übungsaufgaben beitragen.

Einige zu umfangreiche Beispiele wurden gestrafft, andere ergänzt oder aktualisiert. Der Abschnitt über den DDD-Debugger entfiel ebenso wie der zu RCS - beide Werkzeuge sind zwar nach wie vor erhältlich und werden eingesetzt, haben aber nicht mehr die einstmalige Bedeutung. Das Kapitel über Editoren ist ebenfalls deutlich kürzer geworden, da die neuen Versionen der Editoren so selbsterklärend sind, dass Sie dafür wohl nicht extra ein Buch wie dieses benötigen.

Dafür wurde der Abschnitt zu Eclipse um einiges größer. Mittlerweile hat Eclipse in der Verion 3 einen Grad der Reife erreicht, bei dem ich Ihnen dieses Werkzeug guten Gewissens empfehlen kann - auch für die C++-Entwicklung. Im Gegenzug ist der Abschnitt zu SNiFF+ ganz herausgefallen, da es nun mit KDevelop und Eclipse zwei hervorragende freie Entwicklungsgebungen gibt, die es nicht mehr nötig machen, auch eine weitere kommerzielle ausführlich zu behandeln.

Über diese Ergänzungen hinaus habe ich das ganze Manuskript einer kritischen Durchsicht unterzogen und an vielen Stellen die Erläuterungen leicht geändert. Ich hoffe, ich konnte damit die Verständlichkeit des zugegebenermaßen nicht ganz einfachen Inhalts noch etwas verbessern.

Und noch eine Neuerung: Dieser Auflage liegt als erster keine CD-ROM mehr bei. Sie können alle Beispiele und auch die Lösungen zu den Übungsaufgaben unter der bekannten Adresse

http://www.cpp-entwicklung.de

herunterladen. Dort gebe ich Ihnen auch Links zu der Software an, die hier besprochen wird und die bislang teilweise auf der CD-ROM enthalten war. Außerdem finden Sie dort weiterhin den gesamten Text des Buches in HTML-Form zum Nachschlagen und als Online-Referenz.

Ich danke allen Lesern, die mir mit ihren Zuschriften viel positives Feedback gegeben und mich auf die eine oder andere Ungereimtheit hingewiesen haben. Ich würde mich freuen, auch weiterhin Anmerkungen und Eindrücke von Ihnen zu erfahren, am besten per E-Mail unter info@cpp-entwicklung.de.

Vorwort zur ersten Auflage

Die Programmiersprache C++ erfreut sich immer größerer Beliebtheit und Verbreitung. Warum ist das so? Mittlerweile hat sich die Erkenntnis durchgesetzt, dass Wartbarkeit und Wiederverwendbarkeit von Software - zwei Kriterien von wesentlicher Bedeutung - am ehesten durch eine objektorientierte Programmierung erreicht werden können. Und da die Programmiersprache C eine der im technischen Bereich am weitesten verbreiteten ist und C++ deren objektorientierte Erweiterung darstellt, wird die Beliebtheit langsam verständlich.

Kaum ein Entwickler, der technische Software erstellen soll, kommt ohne Kenntnisse in C++ aus. An sehr vielen Arbeitsplätzen dominieren für die Programmierung aber noch die Entwicklungsumgebungen unter Windows, die mit einer mächtigen grafischen Oberfläche ausgestattet sind. Doch werden in jüngster Zeit viele Firmen angesichts der Marktmacht des Windows-Herstellers Microsoft immer skeptischer, ob die Abhängigkeit von einem Anbieter auf Dauer sinnvoll ist, und suchen nach Alternativen. So wird das allgemeine Interesse an Linux immer größer. Handelt es sich dabei doch um ein Betriebssystem, das völlig offen und so gut wie kostenlos erhältlich ist - und sich zudem noch als äußerst stabil und schnell erweist. Außerdem läuft es auf derselben preisgünstigen PC-Hardware wie Windows auch.

Viele Neulinge, aber auch eine Reihe von erfahreneren Entwicklern aus der Windows-Welt, sind angesichts dieses Trends etwas verunsichert. Bei ihnen gilt das Programmieren unter Linux (wie allgemein unter Unix) als unbequem und "steinzeitlich". In diesem Buch will ich Ihnen zeigen, dass diese Vorurteile heute nicht mehr berechtigt sind. Es lässt sich nämlich in der Tat unter Linux ähnlich bequem entwickeln wie unter Windows - wenn auch ein wenig anders, als Sie es möglicherweise bisher kennen. Dafür bekommen Sie aber fast alles, was Sie brauchen, so gut wie umsonst.

Dieses Buch ist für alle,

Ziele und Besonderheiten des Buches

Das Besondere an diesem Buch ist, dass Sie hier nicht nur etwas über die Programmiersprache C++, sondern auch viel über die Werkzeuge lernen, die für die Entwicklung unter Linux zur Verfügung stehen. Der Schwerpunkt der vorgestellten Werkzeuge liegt auf frei erhältlicher Software. Diese ist fast immer nicht nur unter Linux, sondern auch unter den meisten anderen Unix-Plattformen, ja sogar oft unter Windows erhältlich, so dass das Buch für die Benutzer dieser Betriebssysteme ebenso interessant sein kann.

Die Einführung in die C++-Programmiersprache konzentriert sich in diesem Buch auf die objektorientierte Sichtweise. Im Gegensatz zum traditionellen Ansatz vieler Lehrbücher wird daher nicht mit den C-Altlasten begonnen (außer einigen grundlegenden Typen und Operatoren), sondern mit dem Klassenkonzept, d.h. mit Attributen und Methoden, Ableitung und Polymorphismus. Das verlangt von Ihnen sicher einiges an Durchhaltevermögen - wird Sie aber letztlich sehr viel weiter bringen! Denn Objektorientierung ist vor allem eine andere Art des problemlösenden Denkens, als es etwa von den prozeduralen Sprachen verlangt wird.

Zunächst aber erfahren Sie konkret, wie Sie unter Linux entwickeln und welche Werkzeuge Sie dabei tatkräftig unterstützen. In diesem Zusammenhang werden Sie nicht nur die grundlegenden Programme wie Editor und Compiler (einschließlich deren wichtigsten Optionen) kennen lernen, sondern auch moderneren integrierten Entwicklungsumgebungen begegnen, durch die Sie bei der Arbeit produktiver werden können und die Ihnen den Einstieg in die Programmierung (bzw. den Umstieg von Windows) erleichtern sollen.

C++ ist eine sehr mächtige Programmiersprache, die auch den erfahrenen Programmierer immer wieder unsicher machen kann. Alle Details und Probleme können leider im Rahmen dieses Buches nicht behandelt werden. Wenn Sie sich also in der Tiefe mit C++ auseinander setzen wollen, sollten Sie im Anschluss zu einem der vielen guten Fortgeschrittenen-Bücher zu diesem Thema greifen. Die Grundbegriffe und die Entwicklungswerkzeuge kennen Sie ja dann bereits.

Voraussetzungen

Auch wenn Sie noch keine Erfahrung im Programmieren haben, können Sie dieses Buch verwenden. Es ist allerdings hilfreich, wenn Sie bereits Programme geschrieben haben - am besten natürlich in C, da C++ ja darauf aufbaut. Aber auch Kenntnisse in Pascal, Java oder Fortran helfen Ihnen sicher über einige Verständnisprobleme hinweg.

Obschon sich dieses Buch auf die Entwicklungsarbeit unter Linux bezieht, so kann es doch keine Einführung in Linux selbst sein. Ich setze also voraus, dass Sie Linux bereits erfolgreich auf Ihrem Rechner installiert haben und wissen, was eine Shell ist, wie man Verzeichnisse anlegt, Dateien kopiert, verschiebt und löscht und wie Sie sich in einer grafischen Benutzeroberfläche zurechtfinden, die auf dem X-Window-System basiert.

Die Abbildungen von Programm- und Dialogfenstern in diesem Buch sind unter der Oberfläche KDE erstellt worden. Das heißt allerdings nicht, dass Sie unbedingt KDE auf Ihrem Rechner benötigen. Das meiste wird auch mit anderen Window-Managern funktionieren.

Organisation des Buchs

Der erste Teil des Buchs ist der Programmiersprache C++ gewidmet. Dabei starten wir mit einem allgemeinen Überblick, was das Programmieren unter Unix von dem unter anderen Plattformen unterscheidet.

Dann geht es im 2. Kapitel direkt in die Tiefen der objektorientierten Denkweise. An dieser Stelle mag Ihnen der Text zuweilen ein wenig trocken vorkommen; das liegt daran, dass Ihnen zu diesem Zeitpunkt noch zu viele Sprachmerkmale fehlen, um sinnvolle Beispiele erstellen zu können. Andererseits führt Sie das Kapitel aber durch alle wichtigen OO-Aspekte, so dass Sie anschließend Ihre Programme gut danach entwerfen können. Außerdem sehen wir uns in diesem Kapitel noch den GNU-C++-Compiler GCC und seine Bedienung an.

Kapitel 3 ist dem praktischen Programmieren mit C++ gewidmet. Nachdem Sie die theoretischen Konzepte nun schon beherrschen, können wir uns an einige richtige Aufgaben machen. Als Beispiele erstellen wir Programme, die mit Linux-Systembefehlen arbeiten, z.B. die Uhrzeitbestimmung oder die Signalbehandlung,

Anschließend befassen wir uns in Kapitel 4 mit den fortgeschrittenen Sprachmerkmalen wie Templates, der Standard Template Library STL, Operatorüberladung und Ausnahmebehandlung. Hier werden Sie einige Funktionsmerkmale aus dem neuesten ANSI/ISO-Standard kennen lernen, die Sie vielleicht anfangs noch nicht so oft in Ihren eigenen Programmen brauchen werden, die aber zum Verständnis anderer Programme notwendig sind.

Im zweiten Teil geht es um die konkrete Arbeit mit Linux. Als Erstes stelle ich Ihnen in Kapitel 5 einige Editoren vor, mit deren Hilfe Sie Ihre Programme schreiben können. Ob Sie schließlich vi, XEmacs, KEdit, NEdit, XCoral oder etwas ganz anderes einsetzen, bleibt Ihrem Geschmack überlassen.

Danach geht es im 6. Kapitel um verschiedene Werkzeuge, die Sie zum Programmieren neben dem Compiler auch benötigen werden. make dient zur Verwaltung von Quelltexten in mehreren Dateien, der Debugger gdb zur Fehlersuche und CVS zur Versionsverwaltung.

Abschließend lernen Sie in Kapitel 7 verschiedene integrierte Entwicklungsumgebungen kennen, vor allem das sehr komfortable KDevelop, das als Open-Source-Anwendung frei erhältlich ist.

Am Ende des Buches finden Sie noch die zitierten Literaturstellen sowie einige zusätzliche lesenswerte und weiterführende Werke.

Typografische Konventionen

In diesem Buch werden außer dem Fließtext folgende Aspekte durch Formatierungen hervorgehoben:

Begriffe wie "der Programmierer" sind nur der Einfachheit halber in männlicher Form gehalten. Gemeint ist damit immer eine männliche oder weibliche Person.

Aktuelle Ergänzungen

Für dieses Buch gibt es eine Seite im World Wide Web, auf der Sie den gesamten Text sowie Korrekturen, Ergänzungen und Verweise finden. Schlagen Sie nach unter:

http://www.cpp-entwicklung.de

Danksagungen

Wenn man ein Buch wie dieses schreibt, stellt man die Geduld vieler Menschen auf eine harte Probe. Das Feilen und Überarbeiten, um zu einem bestmöglichen Ergebnis für Sie zu kommen, nimmt geraume Zeit in Anspruch. Ich möchte an dieser Stelle dem dpunkt.verlag, insbesondere Herrn Schönfeldt, für die ausgesprochen gute Betreuung in dieser Zeit und darüber hinaus herzlich danken. Viele kompetente Verbesserungsvorschläge kamen von ihm.

Natürlich geht mein Dank auch an meine Frau Andrea, die nun hoffentlich wieder mehr Abende und Wochenenden mit mir wird verbringen können.

Literaturverzeichnis

[ALEXANDRESCU 2001]     ALEXANDRESCU, A.: Modern C++ Design: Generic Programming and Design Patterns Applied. Addison-Wesley, Reading, MA, 2001.

[BOEHM 2000]     BOEHM, O.: Fehlerfrei programmieren mit C und C++. dpunkt.verlag, Heidelberg, 2000.

[BOOCH 1995]     BOOCH, G.: Objektorientierte Analyse und Design. Addison-Wesley-Longman, Bonn, 1995.

[BORZECHOWSKI 2004]     BORZECHOWSKI, M.: Eclipse 3 professionell. Galileo Press, Bonn, 2004.

[BREYMANN 2003]     BREYMANN, U.: C++. Carl Hanser Verlag, München, Wien, 7. Aufl., 2003.

[BRILLOUIN 1956]     BRILLOUIN, L.: Science and Information Theory. Academic Press, New York, NY, 1956.

[BUSCHMANN et al. 1998]     BUSCHMANN, F., R. MEUNIER, H. ROHNERT, P. SOMMERLAD und M. STAL: Pattern-orientierte Software-Architektur -- Ein Pattern-System. Addison-Wesley-Longman, Bonn, 1998.

[CAMERON 1999]     CAMERON, D.: GNU Emacs kurz und gut. O’Reilly, Köln, 1999.

[CAMERON et al. 1996]     CAMERON, D., B. ROSENBLATT und E. RAYMOND: Learning GNU Emacs. O´Reilly & Associates, Sebastopol, CA, 2. Aufl., 1996.

[CARGILL 1992]     CARGILL, T.: C++ Programming Style. Addison-Wesley, Reading, MA, 1992.

[DALHEIMER 1997]     DALHEIMER, M. K.: Linux -- Wegweiser zur Programmierung & Entwicklung. O´Reilly, Köln, 1997.

[DAUM 2003]     DAUM, B.: Java-Entwicklung mit Eclipse 2. dpunkt.verlag, Heidelberg, 2003.

[ECKEL 1999]     ECKEL, B.: Thinking in C++. Prentice Hall, Englewood Cliffs, NJ, 1999. Auch online erhältlich von www.bruceeckel.com.

[ELLIS und STROUSTRUP 1990]     ELLIS, M. A. und B. STROUSTRUP: The annotated C++ reference manual. Addison-Wesley, Reading, MA, 1990.

[FOGEL und BAR 2003]     FOGEL, K. und M. BAR: Open Source-Projekte mit CVS. MITP, Bonn, 2. Aufl., 2003. Teile auch online erhältlich von cvsbook.red-bean.com.

[FRIEDL 2003]     FRIEDL, J. E.: Reguläre Ausdrücke. O’Reilly, Köln, 2003.

[GAMMA et al. 1996]     GAMMA, E., R. HELM, R. JOHNSON und J. VLISSIDES: Entwurfsmuster: Elemente wiederverwendbarer objektorientierter Software. Addison-Wesley-Longman, Bonn, 1996.

[HEROLD 2001]     HEROLD, H.: Das Qt-Buch. Portable GUI-Programmierung unter Linux/UNIX/Windows. SuSE Press, Nürnberg, 2001.

[HEROLD 2003]     HEROLD, H.: make. Das Profitool zur automatischen Generierung von Programmen. Addion-Wesley-Longman, München, 2003.

[HETZE et al. 1997]     HETZE, S., D. HOHNDEL, M. MÜLLER und O. KIRCH: Linux Anwenderhandbuch -- Leitfaden für die Systemverwaltung. Linux AG, Berlin, 7. Aufl., 1997. Auch online erhältlich von www.linux-ag.de.

[JECKLE et al. 2003]     JECKLE, M., C. RUPP, J. HAHN, B. ZENGLER und S. QUEINS: UML 2 glasklar. Carl Hanser, München, 2003.

[JOSUTTIS 1999]     JOSUTTIS, N.: The C++ Standard Library: A Tutorial and Reference. Addison-Wesley, Reading, MA, 1999.

[KERNIGHAN und PIKE 1999]     KERNIGHAN, B. W. und R. PIKE: Programmierpraxis. Addison-Wesley-Longman, München, 1999.

[KERNIGHAN und RITCHIE 1990]     KERNIGHAN, B. W. und D. M. RITCHIE: Programmieren in C. ANSI C.. Carl Hanser, München, 2. Aufl., 1990.

[LACOS 1996]     LACOS, J.: Large Scale C++ Software Design. Addison-Wesley, Reading, MA, 1996.

[LAMB und ROBBINS 1998]     LAMB, L. und A. ROBBINS: Learning the vi Editor. O´Reilley & Associates, Sebastopol, CA, 1998.

[LEHNER 2001]     LEHNER, B.: KDE- und Qt-Programmierung. Addison-Wesley-Longman, München, 2. Aufl., 2001.

[LIPPMAN und LAJOIE 2003]     LIPPMAN, S. B. und J. LAJOIE: C++. MITP, Bonn, 2003.

[LISCHNER 2004]     LISCHNER, R.: STL kurz & gut. O’Reilly, Köln, 2004.

[MATTHEW und STONES 2003]     MATTHEW, N. und R. STONES: Beginning Linux Programming. Wrox Press, Birmingham, UK, 3. Aufl., 2003.

[MATTHEW et al. 2000]     MATTHEW, N., R. STONES und C. BROWNE: Professional Linux Programming. Wrox Press, Birmingham, UK, 2. Aufl., 2000.

[MEYER 1997]     MEYER, B.: Object Oriented Software Construction. Prentice Hall, Englewood Cliffs, NJ, 2. Aufl., 1997.

[MEYERS 1996]     MEYERS, S.: Effektiv C++ programmieren. Addison-Wesley-Longman, Bonn, 1996.

[MEYERS 1997]     MEYERS, S.: Mehr Effektiv C++ programmieren. Addison-Wesley-Longman, Bonn, 1997.

[MUSSER und SAINI 1996]     MUSSER, D. R. und A. SAINI: STL Tutorial and Reference Guide. Addison-Wesley, Reading, MA, 1996.

[PESCHEL-FINDEISEN 2004]     PESCHEL-FINDEISEN, T.: Make ge-packt. MITP, Bonn, 2004.

[POHL 1998]     POHL, I.: C++ for C programmers. Addison-Wesley, Reading, MA, 3. Aufl., 1998.

[PRESS et al. 2002]     PRESS, W. H., B. P. FLANNERY, S. A. TEUKOLSKY und W. T. VETTERLING: Numerical Recipes in C++: The Art of Scientific Computing. Cambridge University Press, New York, NY, 2. Aufl., 2002.

[PURDY 2004]     PURDY, G. N.: CVS kurz & gut. O´Reilly, Köln, 2004.

[RAYMOND 1999a]     RAYMOND, E.: The Cathedral and the Bazaar. www.catb.org/~esr/writings/cathedral-bazaar, 1999a.

[RAYMOND 1999b]     RAYMOND, E.: The Magic Cauldron. www.catb.org/~esr/writings/magic-cauldron, 1999b.

[SALUS 1994]     SALUS, P.: A Quarter Century of UNIX. Addison-Wesley, Reading, MA, 1994.

[SCHMID 2001]     SCHMID, H.: Linux-Sprinter: Intel C++-Compiler für Linux. c’t - Magazin für computer technik, (23):222-224, 2001.

[SEDGEWICK 1992]     SEDGEWICK, R.: Algorithmen in C++. Addison-Wesley-Longman, Bonn, 1992.

[STOER 2004]     STOER, J.: Numerische Mathematik: eine Einführung. Springer-Verlag, Heidelberg, Berlin, 9. Aufl., 2004.

[STROUSTRUP 1993]     STROUSTRUP, B.: The C++ programming language. Addison-Wesley, Reading, MA, 1993.

[STROUSTRUP 1994]     STROUSTRUP, B.: Design and evolution of C++. Addison-Wesley, Reading, MA, 1994.

[STROUSTRUP 1998]     STROUSTRUP, B.: Die C++ Programmiersprache. Addison-Wesley-Longman, Bonn, 3. Aufl., 1998.

[SUTTER 2000]     SUTTER, H.: Exceptional C++. Addison-Wesley, Reading, MA, 2000.

[SWEET 2001]     SWEET, D.: KDE 2 Programmierung - Komponentenbasierte Anwendungen mit Qt, kparts und DCOP. Markt + Technik, München, 2001.

[Taligent 1994]     TALIGENT, 1994.: Taligent’s Guide to Designing Programs: Well-Mannered Object-Oriented Design. Addison-Wesley, Reading, MA.

[TORVALDS und DIAMOND 2002]     TORVALDS, L. und D. DIAMOND: Just for Fun. Deutscher Taschenbuch Verlag, München, 2002.

[WERRY und MOWBRAY 2000]     WERRY, C. und M. MOWBRAY, Hrsg.: Online Communities: Commerce, Community Action, and the Virtual University. Prentice Hall, 2000.

[WHEELER 2001]     WHEELER, D., 2001.: Program Library HOWTO. www.dwheeler.com/program-library.

[WIELAND 2000]     WIELAND, T.: Linux als Geschäftsfaktor. Linux Enterprise, (2):20-24, 2000. Auch online erhältlich von www.drwieland.de/articles/Linux_Geschaeftsfaktor.htm.

[WIELAND 2001]     WIELAND, T., 2001.: Open Source im Unternehmen. In: RAISON, A.V. und R. SCHÖNFELDT, Hrsg.: Linux im Unternehmen, S. 10-40. dpunkt.verlag, Heidelberg.

[WIELAND 2004]     WIELAND, T., 2004.: Stärken und Schwächen von Open Source im Unternehmen. In: LUTTERBECK, B. und R. GEHRING, Hrsg.: Open Source in Deutschland: Jahrbuch 2004. Lehmanns, Berlin.

Index

Ausnahmebehandlung, 90

bad_alloc, 99
bad_cast, 61, 99
Bibliothek, 17
Binärdatei, 64

C++-Standardbibliothek, 44
catch, 91
CodeWarrior, 135
Compiler, 16
const_cast, 62
Container, 48

DDD
    unter SNiFF+, 128
Debugger, 106
Defensives Programmieren, 89
Distribution, 11
dynamic_cast, 60

Ediff, 107
Exception handling, 90
extern, 23

Freie Software, 14
friend, 80
Funktion
    generische, 29

gdb, 106
gdb
    unter SNiFF+, 127
generische Funktion, 29
GNU Debugger, 106
GNU Public License, 14
GNU-Projekt, 12
GPL, 14

Header-Datei, 16

IDE, 103
Indexoperator, 70
Inkrementoperator, 72
Integral (numerisches), 43

KDevelop, 137
Kellerspeicher, 94
Kernel, 10
Komplexe Zahlen, 77
Konkatenation, 47
Konstruktor
    Typumwandlungs-, 82

Linker, 17
Liste
    verkettete, 51
logic_error, 99

man-Kommando, 104
Map, 48
Menge, 48
Multimenge, 48
Multitasking, 8
Multiuser-Konzept, 8

Namensraum, 22, 45
namespace, 22

operator (Schlüsselwort), 67
Operatoren
    Überladen von, 67
    Typumwandlung, 59
Operatorfunktionen, 67

Postfixoperator, 72
Prädikat, 56
Präfixoperator, 72
Prototyp, 32

Qt, 112
Quelltext, 16
Queue, 48

RCS, 107
read() (Methode von istream), 64
Referenz
    konstante, 71
reinterpret_cast, 63
RTTI, 60
Run-Time Type Information, 60
runtime_error, 99

Signatur
    einer Funktion, 30
sizeof(), 65
SNiFF+, 110
    Build Options, 114
    Editor, 121
    Hierarchiebrowser, 119
    Klassenbrowser, 118
    Make-Support, 123
    Private working environment, 131
    Projekteditor, 112
    Repository working environment, 129
    Shared object working environment, 131
    Shared source working environment, 130
    Symbolbrowser, 117
    Target Dialog, 127
    Working environments, 128
source code, 16
Source Navigator, 134
Spezialisierung, 40
Stack, 51, 94
Standardbibliothek, 44
static_cast, 59
std (Namensraum), 23, 45
string, 46
Strings, siehe Zeichenkette
Syntax, 16

throw, 92
Trapez-Regel, 43
try, 91
typedef, 39
Typumwandlung
    Operatoren, 59
Typumwandlungskonstruktor, 82
Typumwandlungsoperator, 82

Unix, 7
using, 25

Vektor, 49
Versionskontrolle, 107
vi-Editor, 122
void*, 41

Workstation, 7

XEmacs, 104
    Ediff, 107
    unter SNiFF+, 122

Zeichenkette, 46
Zeiger
    auf void, 41