Dies wird das Abschlusskapitel des C-Kurses, denn alles wichtige habe ich vorgestellt, um selbst die ersten Schritte in die eigene Programmentwicklung zu machen. Wir haben gelernt, Funktionen zu schreiben und sinnvoll anzuordnen. Nun ist es an der Zeit, sich aus der vielfälltigen Auswahl von Bibliotheken (Libraries) zu bedienen und deswegen werden wir uns nun eine externe Bibliotheken ansehen, diese Einbinden und die Funktionen darin nutzen.

Beispiele für derartige Bibliotheken sind

• Graphische Oberflächen (GTK+, Qt-Tutorial, wxWidgets)
• Spieleprogrammierung (Allegro, SDL, OpenGl)
• Datenbanken (SQLite, MySQL)

Es gibt Bibliotheken für eine Vielzahl von Problemen.

Die passende Bibliothek findet sich in der Regel durch eine Recherche mit einer Suchmaschine, bzw. durch Nachfragen in einem passendem Forem, wie das unsrige oder ein auf C und C++ spezialisiertes wie unter http://www.c-plusplus.de/forum/.

Wir schauen uns als Beispiel die graphische Oberfläche GTk an, hier werden wir eine einfache Messagebox zeichnen lassen.

Externe Libraries sind prinzipiell auch nur Objektfiles, wie unsere eigenen kompilierten Quelltexte auch. Linkt man die Objektfiles zu den eigenen Programmen hinzu, so kann man auf diese Funktionen zugreifen. Fertig.

Nun kann nicht jedes Programm ein komplettes Betriebsystem hinzulinken, um Fenster darzustellen, Dateien zu öffnen und so weiter. Damit die Programme nicht zu groß werden, werden diese Funktionen von allen Programmen verwendet: Alle Programme benutzen das Betriebsystem, es muss nicht pro Programm neu geladen werden. Das Betriebsystem ist aus Sicht des Entwicklers nur ein großer Haufen von externen Libraries. Unter Linux nennt man sie daher „Shared Libraries“, also Bibliotheken, die man sich mit anderen teilt. Unter Windows geht man die Sache eher technisch an und nennt sie „Dynamic Linked Library“, kurz DLL. Das Konzept ist aber das gleiche: Man packt die Funktionen in die 'Shared Lib'/DLL. Zu jeder dynamisch gelinkten Bibliothek gehört eine statische Bibliothek, die nichts anderes macht, als die versprochenen Funktionennamen (nicht deren Funktion) für unser Programm zur Verfügung zu stellen. Beim Start unseres Programm wird das Betriebsystem aufgefordert, die dynamische Bibliothek zur Verfügung zu stellen. Hier für wird die dynamische Library entweder geladen oder sie ist bereits im Speicher und wir teilen sie uns mit dem Programm, dass sie zuvor geladen hat. Wir selbst rufen mit unserem Programm nun die Funktionen, die sich in der statischen Library befinden. Diese Funktionen selbst haben nur die Aufgabe, die Funktionen zu rufen, die sich in der dynamischen Bibliothek befinden. Davon bekommen wir selbst eigentlich gar nichts mit. Entsprechend macht es für uns eigentlich kaum einen Unterscheid, ob wir statische oder dynamische Bibliotheken verwenden. Im Falle der dynamischen Bibliotheken müssen wir lediglich dafür sorgen, dass diese zusätzlichen Dateien auch gefunden werden. Wir müssen also sicherstellen, dass sie mit dem Betriebsystem ausgeliefert werden oder sie (z.B. bei der Installation) in passende Verzeichnisse kopieren.

Surfen wir mal auf gtk.org vorbei und klicken oben auf 'Download'. GTk ist für Linux, Mac und Windows verfügbar.

Am einfachsten haben es wie immer die Linux-Benutzer, die einfach ihre Paketverwaltung beauftragen, die Developerfiles herunter zu laden:

Zum Beispiel Debian-Derivate (z.B. Ubuntu)

aptitude install libgtk2.0-dev

Damit wären wir fertig und können beim Testen der Lib weiterlesen. (Für andere Linux-Distributionen siehe hier)

Unter Windows verwenden wir die 32-Bit-Version, da die 64-Bit Version noch in Entwicklung ist, bzw. die 32 Bit Version auf allen Windows-Versionen läuft.

Als Windowsbenutzer lädt man ein etwa 25 MB großes ZIP-Archiv herunter und dieses werden wir uns beispielhaft mal ansehen. Vor der Benutzung von WinZip wird im Readme gewarnt, ich habe einfach die in Windows eingebaute ZIP-Funktionalität verwendet und das Archiv in dieses Verzeichnis entpackt. Ausgepackt haben wir nun rund 108 MB Dateien.

Während die Paketverwaltung der Linux-User schon alles erledigt hat, müssen die Windows-Benutzer noch einige Dinge tun, um die Library ans Laufen zu bekommen. Dem Archiv liegt eine ReadMe-Datei bei, die die notwendigen Schritte erklärt. Für die derzeit aktuelle Version 2.22 werden wir diese hier nun durchführen. Bei einer neueren Version kann es sein, dass zusätzliche Schritte erforderlich sind.

Wie vorgeschlagen werden wir einen Ordner „c:\opt\gtk“ erstellen. Vor der Benutzung von WinZip wird im Readme gewarnt, ich habe einfach die in Windows eingebaute ZIP-Funktionalität verwendet und das Archiv in dieses Verzeichnis entpackt.

Im Verzeichnis „bin“ befinden sich einige Programme, die mit GTk mitgeliefert wird und - noch viel wichtiger, die ganzen „Shared Libs“, die DLLs. Damit Windows diese Programme und DLLs finden kann, muss Windows darüber informiert werden, dass es in diesem Verzeichnis suchen muss. Dafür fügen wir den Pfad „c:\opt\gtk\bin“ in die Pfad-Variable ein.

Dafür halten wir die Windows-Taste fest und drücken die Taste „Unterbrechen“ (oben rechts, über der Bild-Aufwärts-Taste) oder gehen in die Systemsteuerung, dort auf „System und Sicherheit“ und dort wählen wir „System“ aus. Nun wählen wir „Erweiterte Einstellungen“ und ein neues Fenster geht auf.

Hier klicken wir auf Umgebungsvariablen und schon haben wir wieder ein neues Fenster. Hier suchen wir in den Systemvariablen die „PATH“-Variable heraus und doppelklicken hier.

Und schon haben wir noch ein Fenster. Den Namen der Variable lassen wir natürlich, aber den Wert ergänzen wir. Es wird nichts gelöscht, nur am Ende wird „;c:\opt\gtk\bin“ hinzugefügt. Das Semikolon als Trennsymbol zwischen den Pfaden und anschließend der Pfad zu den GTK-Libraries.

Anschließend alles mit Okay bestätigen, hier sind wir fertig. Probieren wir es aus. Wir öffnen eine neue Eingabeaufforderung (sie muss neu geöffnet werden, denn eine bereits offene Eingabeaufforderung würde die Änderung nicht mitbekommen). Schauen wir uns also an, ob die Variable wie erwartet den zusätzlichen Pfad enthält. Der Inhalt der Variable muss nicht identisch mit dem Bild sein, nur am Schluss muss eben unsere Ergänzung stehen:

Nun sollte hier auch alles laufen.

Anschließend rufe ich hier das Programm „gtk-demo“ auf. Wenn die alles läuft geht nun ein Fenster auf, dass zeigt, was GTk so kann und macht:

'gtk-demo' ist ein wunderbare Form der Dokumentation. Mit einem Doppelklick auf einen Eintrag der linken Liste geht ein Beispiel auf, auf der rechten Seite sieht man entweder eine Information, was das Beispiel demonstriert und wenn man oben auf auf „Source“ klickt, sieht man den Quelltext, bei dem man sehen kann, wie man das zu programmieren hast.

Ausführlicher erklärt das das GTk-Tutorial auf proggen.org.

Schließen wir das Demoprogramm, GTk läuft.

Wenn wir nun in „C:\opt\gtk\etc\gtk-2.0“ eine Datei „gtkrc“ (nicht gtkrc.txt!) erstellen und dort eine Zeile einfügen:

gtk-theme-name = "MS-Windows"

benutzt, wird die Oberfläche eher an Windows angelehnt.

Ziel dieser Lektion ist nicht mit Gtk aufwendige graphische Oberflächen zu erstellen, sondern nur eine externe Library zu verwenden. Wir werden also nur ein ganz einfaches Programm kompilieren:

#include <gtk/gtk.h>
 
int main( int argc, char ** argv )
{
  GtkWidget *dialog;
 
  /* Gtk initialisieren */
  gtk_init(&argc, &argv);
 
  /* MessageBox erzeugen und anzeigen */
  dialog = gtk_message_dialog_new( NULL,
				   GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
				   GTK_MESSAGE_INFO,
				   GTK_BUTTONS_OK,
				   "Wir benutzen eine externe Library\n"
				   "proggen.org-Tutorial");
 
  gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG(dialog), 
                                            "Das erste Argument: %s", 
                                            (argc > 1) ? argv[1] : "-nicht angegeben-" );
 
  gtk_dialog_run (GTK_DIALOG (dialog));
 
  /* Daten freigeben */
  gtk_widget_destroy (dialog);
 
  /* fertig */
  return 0;
}

Prinzipiell geht es nun darum, dem Compiler mitzuteilen, wo er die Inklude-Dateien findet und dem Linker, wo er die statischen Bibliotheken findet. Gtk liefert für die Konfiguration ein praktisches Tool mit namens pkg-config. Mit pkg-config –list-all lassen sich alle Namen bekannter Konfigurationen auflisten. Wir arbeiten hier mit „gtk+-2.0“. Die Ausgabe von pkg-config erfolgt passend für den GNU-Compiler. Für den Compiler benötigen wir die C-Flags:

und für den Linker die Libs:

Benutzer des GCC-Compilers bzw. von 'make' haben es jetzt sehr einfach, sie fügen die Ausgaben direkt an den Compileraufruf an. Benutzer einer Entwicklungsumgebung müssen jetzt erst einmal den ganzen Kram in Ihre Entwicklungsumgebung übertragen.

Schauen wir uns das ganze also für die einzelnen Fälle an:

• Make-Skript anpassen

• CodeBlocks (Linux, Mac, Windows)
• CodeLite (Linux, Mac, Windows)
• Visual C++ 2010 (Express) (nur Windows)
• XCode (nur Mac)

Wie immer rate ich dazu, sich Make in jedem Fall anzusehen.

Wie immer das Projekt am Schluss gebaut wird, das Ergebnis sollte ungefähr so aus sehen:

Mit der Verwendung von externen Bibliotheken steht Dir nun die Welt offen, beliebige Software zu schreiben. Allerdings erfordert jede Library eine gewisse Menge an Einarbeitungszeit. Und genauso muss auch erst in die Verwendung der Sprache C eine gewisse Routine erfolgen. Wenn Du Dich am Ende des Tutorials also noch häufig überfordert fühlst, dann ist das absolut normal.

Im Forum findest Du Hilfe zu Deinen ganz individuellen Problemen und mit wachsender Erfahrung wirst Du auch in die Lage versetzt Fragen anderer beantworten zu können.

Wir würden uns sehr freuen, wenn Du uns von Deinen Projekten berichtest und wenn Dir das Tutorial gefallen hat, freuen wir uns, wenn Du andere Interessierte einlädst, es ebenfalls zu Lesen. Du selbst kannst bist nun bereit Dich in eine Library einzuarbeiten und erste eigene Programmiererfahrung zu sammeln oder z.B. mit dem C++-Tutorial noch weiter in die Programmierung einzusteigen.

Viel Spaß