Benutzerhandbuch zu KDevelop: Programme

Weiter Zurück Inhaltsverzeichnis

### 3. Programme

Nachdem KDevelop erfolgreich installiert und die allgemeinen Einstellungen vorgenommen sind, möchten Sie wahrscheinlich wissen, ob die Entwicklungsumgebung hält, was sie verspricht. Dieses Kapitel gibt Ihnen einen Leitfaden, wie Programme allgemein mit den GNU Werkzeugen erzeugt werden und welchen Teil speziell KDevelop in diesem Prozeß übernimmt.

### 3.1 Der Compiler

Der Compiler ist letztlich das Programm auf Ihrem System, das mindestens installiert sein muß um laufende Programme zu erzeugen; er ist derjenige, der den Quellcode in Objektdateien übersetzt und das Programm erzeugt.

Normalerweise würden Sie so starten: Öffnen Sie einen Editor Ihrer Wahl - benutzen Sie keine Textverarbeitung. Geben Sie etwa dieses ein, um den Quellcode Ihres ersten Programmes zu schreiben:

> `

>     #include <iostream.h>

>     int main(){

>     cout << "Hello World" << endl;

>     }

> `

Nun, alles, was das Programm tun wird, ist den String "Hello World" auf Ihrer Standardausgabe auszugeben. Aber dies ist nur der Quellcode für ein zu erstellendes Programm, nicht das Programm selbst. Daher benötigen Sie einen Compiler, in diesem Fall ein C++-Compiler wie etwa g++. Dann können Sie den Quellcode als Datei speichern, sagen wir als myprogram.cpp und den Compiler mit dem Dateinamen aufrufen (auf einer Konsole):

> `

>     g++ -o myprogram myprogram.cpp

> `

Danach können wir unser Programm starten- geben Sie einfach `myprogram` auf der Konsole ein, und das Programm gibt den String aus und beendet sich.

### 3.2 Make und Makefiles

Ich habe jetzt alles, was ich brauche: einen Editor, einen Compiler und ich kann mein eigenes C++ Programm ausführen. Aber es ist nicht ganz so einfach. Was passiert, wenn Sie mehr als eine Quellcodedatei haben? Und, müssen Sie dann die Quellen immer wieder übersetzen, wenn Sie nur eine Datei geändert haben? Der Übersetzungsvorgang wird immer komplizierter und zeitraubender, weil Sie alle Kommandos und Optionen selbst eintippen müssen. Deshalb können Sie sich ein sogenanntes "Makefile" schreiben. Man könnte es genausogut anders nennen, außer dem Namen des Programms, das zu erstellen ist. Dann sollten Sie das Werkzeug `make` oder `gmake` installiert haben, oder ein anderes Werkzeug, das den Übersetzungsvorgang überwacht. Fügen Sie alle Compileranweisungen in der speziellen Erstellungssyntax in das Makefile ein und speichern Sie es; danach brauchen Sie nur noch `make` oder `gmake` auf der Konsole in dem Verzeichnis einzugeben, wo sich das Makefile befindet; make übernimmt dann und bringt den Compiler dazu Ihr Programm zu erzeugen. Das Make-Werkzeug hat noch viele weitere Vorteile und kann zu vielen Zwecken verwendet werden. Um eine Übersicht zu bekommen, öffnen Sie eine Konsole und geben Sie ein:

`man make`

oder suchen Sie nach "GNU Make" in der KDE-Hilfe unter "System GNU Info contents".

Dies erklärt Ihnen, warum ein Entwickler das Make-Werkzeug benötigt, um den Übersetzungsvorgang seiner Applikation zu vereinfachen. Nun, das Schreiben der Makefiles ist jetzt nicht nur Handarbeit, Sie müssen sich auch noch in die Syntax und die Optionen hineinarbeiten. Aber hier ist die gute Nachricht über KDevelop und das Make-Werkzeug: Sie müssen nur das Make-Kommando im KDevelop Setup Dialog setzen und Sie sind soweit. Alle Projekte, die von KDevelop erzeugt werden, benutzen das Make-Kommando um die Zielapplikation zu erstellen, und Sie müssen nichts eingeben. Klicken Sie einfach auf den Make-Knopf in der Werkzeugleiste oder wählen Sie die gewünschte Funktion aus dem "Erstellen" Menü.

Die Werkzeugleiste und das "Erstellen"-Menü bieten die meist benutzten Funktionen, um make die Arbeit erledigen zu lassen:

- Datei compilieren: ist nur aktiv, wenn Sie an einer Quellcode-Datei arbeiten. Diese Funktion ruft make mit dem korrekten Kommando auf, nur die aktuelle Quelldatei zu übersetzen.
- Erstellen: ruft make auf und erzeugt das Zielobjekt (die Applikation)
- Alles neu erstellen: löscht alle schon übersetzten Dateien und erstellt das Projekt neu
- Säubern/alles neu erstellen: löscht alle übersetzten Dateien inklusive der Konfigurationsdateien des Projekts und erstellt alles neu
- Stoppen: beendet den aktuellen Prozeß
- Ausführen: erstellt die Zieldatei und führt das Programm aus
- Mit Argumenten ausführen: erstellt die Zieldatei und gibt Ihnen die Möglichkeit, dem Programm vor seiner Ausführung Kommandozeilenoptionen zu übergeben.
- Debuggen: erstellt die Zieldatei und startet KDbg mit dem Programm, um es zu debuggen

Aber dies ist nicht das einzige, wo KDevelop mit make zusammenarbeitet- bei KDE Applikationen sind einige Dinge speziell auf die Unterstützung des Entwicklers abgestimmt wie die Erzeugung der Messages-Datei für die Internationalisierung Ihres Projekts. Diese Funktionen sind ebenfalls sorgfältig integriert, so daß Sie sich darüber nicht mehr den Kopf zerbrechen müssen.

Bis jetzt wissen Sie schon einiges über Quelldateien, den Compiler und warum make benötigt wird. Im nächsten Abschnitt werden wir besprechen, warum Projekte, die mit KDevelop erstellt wurden, automatisch durch Verwendung eines `configure`-Scripts auf den meisten Unix-Plattformen übersetzt werden können.

### 3.3 Configure

Der Titel dieses Abschnitts- Configure, bedeutend soviel wie Konfiguriere - läßt Sie wahrscheinlich fragen: Konfiguriere ? Was muß konfiguriert werden ? Oder wer ?

Nun, gehen wir davon aus, daß Sie ein Programm geschrieben haben inklusive einem Makefile. Dann wollen Sie es verbreiten, aber die compilierte Binärdatei läuft nur auf Ihrem System und auf solchen, die mit Ihrem kompatibel sind. Um andere Plattformen zu unterstützen wie die verschiedenen Unix-Systeme oder Maschinen wie Alpha's oder RISC's müssen Sie ihr Programm neu übersetzen. Der einfachste Weg wäre, das Quellpaket auf die Zielmaschine zu kopieren und `make` nochmals laufen zu lassen. Aber was wäre, wenn die Zielmaschine einen anderen Compiler benutzt oder in anderer Weise ein Problem erzeugt, die ein Erstellen des Programms verhindert ? Nicht zu erwähnen die schwierigeren Dinge wie der Installationspfad für Ihr Programm und Dokumentation- z.B. kann KDE auf einer Maschine unter ``opt/kde/ installiert sein, auf einer anderen aber unter `usr`local/kde/. In diesem Fall müßten Sie das Makefile immer bearbeiten, um eine korrekte Übersetzung und Installation Ihres Produkts sicherzustellen.

Glücklicherweise haben die GNU-Werkzeuge noch mehr zu bieten als das mächtige `make`- die allgemein genutzten Pakete automake und autoconf. Es klingt gut, etwas mit "auto"- es scheint als ob etwas beim Applikations-Design einfach und schnell gemacht werden kann, was auch genau den Punkt trifft.

Der Zweck von `automake` ist generell, die sogenannten `Makefile.in`'s aus der Datei `Makefile.am` zu erstellen, die Sie für Ihr Projekt anstatt einer "richtigen" Makefile schreiben müssen. Diese Makefile.am besteht aus Makros, die leicht zu verstehen ist Komplexität reduziert, die make anbietet, so daß eine Makefile.am fehlerloser und schneller geschrieben werden kann als das letztliche Makefile.

Aber wer erzeugt mir dann letztlich mein Makefile ? Nun, hier kommt autoconf. Autoconf benötigt verschiedene Makrodateien für das Projekt. Diese sind die Makefile.in's, die automake erzeugt hat und eine Datei namesn `configure.in`, die auch aus Makros besteht. Hierbei beinhalten die Makefile.am und .in's die Makros die dafür verantwortlich sind, wie das Ziel erstellt wird in Bezug auf die Quellen, die übersetzt werden müssen, welche Dateien zum Paket gehören und welchen Namen die letzliche Binärdatei oder Bibliothek nach einem Erstellungsvorgang hat. `configure.in` andererseits beinhaltet die Makros, nach denen das letztliche configure-Skript das System prüft, auf denen configure ausgeführt wird. Dies können z.B. das Compiler-Kommando, benötigte Bibliotheken zu denen die letzliche Binärdatei gelinkt wird und include-Dateien, die das Projekt benötigt, sein.

Wenn Sie z.B. eine KDE Applikation schreiben und nach der Fertigstellung Ihr Programm Benutzern zur Verfügung stellen möchten, muß jeder Benutzer die Binärdatei selbst compilieren. Dann würden Sie eine `configure.in` Datei, die die Makros für eine KDE-kompatible Applikation enthält. Diese Makros werden dann expandiert zu einer Systemprüfung, ob die Qt-Bibliothek installiert ist, dem Pfad der Qt-Headerdateien, den KDE Bibliotheken und Headern etc.

Zusammenfassung: Um eine GNU-gemäße Applikation zu erstellen, die auf verschiedene Unix-Betriebssysteme und andere Maschinen als Ihre eigene portabel sein soll, müssen Sie folgendes ausführen:

1. die Quellen Ihres Projekts schreiben
2. eine Makefile.am für jedes Unterverzeichnis erstellen, inklusive dem Hauptverzeichnis Ihres Projekts
3. eine configure.in Datei im Hauptverzeichnis erstellen, das die Makros für die Systemanforderungen enthält
4. automake aufrufen
5. autoconf aufrufen

Dann ist die Hauptarbeit getan. Automake erzeugt die Makefile.in's, autoconf läuft über die `configure.in` und erzeugt das ausführbare Shellscript `configure`. Alles, was Sie dann zu tun haben, ist die Ausführung mit `./configure`, und das Skript wird die Prüfungen durchführen. Schließlich werden die Makefiles erzeugt, die die Ausführung von make (oder gmake) erlauben, um das Projekt zu erstellen.

Dies alles scheint ein bißchen viel zu sein, nur um eine kleine Applikation zu schreiben und auch viel zu lernen, speziell die korrekten Makros. Aber allein der Umstand, daß Sie damit einen Kompiliervorgang auf fast allen Unix-Systemen erreichen, macht die Arbeit früher oder später wett. Schließlich müssen Sie diese Arbeit auch nur einmal für das Projekt machen und im Fall, daß Ihre Projektdateien anwachsen, brauchen Sie ja nur die Dateinamen den Makros hinzufügen.

Nun, inwiefern unterstützt KDevelop diese Art der Applikationserstellung und wie kompliziert wird es für den Programmierer? Die gute Nachricht für Sie ist: Sie brauchen noch nicht eimal etwas über Makros und Skripte zu wissen. Alle Details sind hinter einer einfach zu bedienenden graphischen Benutzeroberfläche versteckt, die die Arbeit für Sie übernimmt. Eine Applikation wird mit den GNU-Tools deshalb auf sehr benutzerfreundliche Art erstellt:

Erzeugen Sie Ihre Applikation einfach mit dem KAppWizard nach Wahl der Bedürfnisse Ihrer Applikation- es mag ein reines C++ Terminalprogramm sein oder eine Art GUI Programm, das die Qt oder die Qt/KDE Bibliothek benutzt. Die ganze Arbeit wird für Sie erledigt und Ihr Projekt enthält schon die Makefiles, die durch eine automatische Ausführung der GNU-Tools und des configure-Skripts erstellt wurden.

Das wäre es schon- Sie brauchen nur die Quellen Ihres Projekts zu erweitern, sei es durch Hinzufügen von Klassen, Dialogen, Übersetzungen oder Dokumentation, was auch vollständig automatisiert abläuft. Konzentrieren Sie sich einfach auf die wirkliche Arbeit eines Entwicklers, nämlich Ihrer Applikation Funktionalität zu verleihen. In den meisten Fällen werden Sie wahrscheinlich nie mit Makefiles in Berührung kommen, wenn Sie KDevelop benutzen.

### 3.4 Debuggen

Der folgende Abschnitt betrachtet einen Terminus, der unter Entwicklern weit verbreitet ist: Debuggen. Das bedeutet, daß, obwohl Ihr Compiler die letzliche Applikation erzeugt, das Programm aber nicht läuft oder während der Ausführung abstürzt wegen eines sogenannten "Bugs" (Käfer) im Code. Ein Programmfehler, der mit dem Namen dieser Insekten beschrieben wird, stammt aus der Geschichte des Computers; einer der ersten Fehler, die eine Maschine zum Absturz brachte, war keine offensichtliche Fehlfunktion- Käfer waren in den Computer eingedrungen und waren dafür verantwortlich. Daher beschreibt man einen Fehler, der auf den ersten Blick nicht offensichtlich ist, als einen "Bug", daher bedeutet "Debuggen", die Käfer zu entfernen, wo sie nicht hingehören. Nun, Sie brauchen sie nicht wirklich zu jagen; vorausgesetzt daß die heutigen Computer konzipiert sind, diese durch einen Schutz fernzuhalten. Sie müssen innerhalb des Codes gefunden werden, wenn sie die Ausführung eines Programms mit der Nachricht "Segmentation fault" (Speicherverletzung) beenden. GNU bietet dazu ein weiteres Werkzeug, `gdb`, den GNU Debugger. Dieses Terminalprogramm erlaubt es, die internen Werte einer Applikation und die Ausführung durch setzen von Haltepunkten im Code zu beobachten. Gdb stoppt die Ausführung jedes mal, wenn das Programm an einen Haltepunkt kommt. Aber wie die meisten Werkzeuge wird auch der Debugger von einem anderen Programm gesteuert, das ein Frontend dazu bietet und es erlaubt, die Werte einfach zu beobachten und Haltepunkte im Code zu setzen.

Zu diesem Zweck wird die Applikation Ihres Projekts standardmäßig mit der Compileroption zum Debuggen erzeugt und speichert daher zusätzliche Daten in der Binärdatei, um die Werte und Zeilen im Code zu lokalisieren. Als Frontend zu gdb benutzt KDevelop das Programm KDbg, den KDebugger. Um Ihr Programm zu debuggen, müssen Sie nur "Debuggen" im "Erstellen" Menü auswählen oder den entsprechenden Werkzeugleistenknopf betätigen, der durch ein Rad mit Brille dargestellt wird und signalisiert, das Sie die Ausführung beobachten wollen.

KDevelop öffnet dann das Werkzeuge-Fenster und startet Ihr Programm mit KDbg. Die KDbg Oberfläche erscheint dann innerhalb des Werkzeuge-Fensters und erlaubt die Benutzung genauso als ob Sie den Debugger außerhalb von KDevelop gestartet hätten.

Ganz allgemein zeigen die obigen Schritte, das ein Entwickler zum Schreiben seines eigenen Programms verschiedene Stufen durchlaufen muß, um ein Projekt zu beginnen. Auch erklärt dies, welchen Teil KDevelop dabei übernimmt und wie die Entwicklungsumgebung die Idee eines einfachen Wegs zur Unix-Programmierung unterstützt. Um weitere Informationen über die GNU Tools zu erhalten, sollten Sie die zugehörige Dokumentation lesen, die Sie allgemein über das `man` Kommando oder über "System GNU Info contents" in der KDE Hilfe nachschlagen können.

Weiter Zurück Inhaltsverzeichnis