Anhang: Einführung in die Programmierumgebung Code::Blocks

Anhang: Einführung in die Programmierumgebung Code::Blocks
1 Einleitung
Professionelle Softwareentwicklung fordert heutzutage von den Entwicklern in stetig kürzer
werdenden Entwicklungszyklen immer hochwertigere Produkte zu erstellen. Diese Produkte
sollen zudem leicht erweiterbar und anpassbar sein. Neben einem fundierten Fachwissen,
ausreichender Programmiererfahrung und der Kenntnis neuester Programmiertechnologien sind
es vor allem auch die Wahl der richtigen Entwicklungsumgebung, die es dem
Softwareentwickler ermöglichen die steigenden Anforderungen erfüllen zu können.
Das wesentliche Lernziel des Praktikums „Grundlagen der Programmentwurfstechnik“ besteht
darin, einerseits die in der Vorlesung vorgestellten Methoden der strukturierten Analyse anhand
einer praktischen Aufgabenstellung auf den Entwurf eines komplexen Systems anzuwenden.
Andererseits sollen die einzelnen Studententeams den Entwurf in ein lauffähiges Programm
umsetzen. Ein weiteres Lernziel ist dabei den Prozess der Softwareentwicklung "zu erleben" und
die vielfältigen Anforderungen an die Projektorganisation und -durchführung aus Praxissicht zu
erfahren. Um diese Erfahrungen abzurunden wird auch der Einsatz einer integrierten SoftwareEntwicklungsumgebung (SEU) empfohlen. Hierzu wird den Studierenden die SEU Code::Blocks
zur Verfügung gestellt. Die ersten beiden Praktikumstermine führen allgemein in die Struktur
und den Aufbau einer SEU ein und demonstrieren deren Nutzung am Beispiel von Code::Blocks.
2 Integrierte Software Entwicklungs Umgebungen (SEU)
Eine integrierte Softwareentwicklungsumgebung (engl.: IDE – Integrated Development
Environment) unterstützt die Entwickler in nahezu allen Phasen des Software Lebenszyklus,
ausgehend von der Anforderungsanalyse über den Entwurf und die Implementierung bis hin zum
Test und zur Wartung. Üblicherweise bietet eine SEU unter einer einheitlichen
Benutzeroberfläche verschiedene Werkzeuge an, wie z.B. Compiler, Editor, Debugger, Linker
und Projekt Manager. Abhängig von der Komplexität bzw. Vollständigkeit der IDE werden auch
Komponenten zur Online-Dokumentation, Textmustererkennung und Mehrbenutzer Support
bereit gestellt. Neben einer Vielzahl kommerzieller Produkte sind auch freie SEU verfügbar. Die
Wahl der „richtigen“ Programmierumgebung ist abhängig von der Art und der Größe des Projeks
und wird zudem beeinflusst durch die Erfahrung aber auch den „Geschmack“ des
Programmierers. Die „richtige“ SEU unterstützt die Programmierung, führt zu einer größeren
Effizienz und steigert damit die Produktivität der Entwicklerteams und erhöht die Qualität des
Endproduktes.
2
IDE Komponenten
Als Kernkomponenten enthalten heutige SEU je einen Compiler, Debugger, Builder, Editor und
Projekt Manager. Die allgemeine Funktion der einzelnen Komponenten wird nachfolgend
beschrieben.
Abbildung 1 IDE Kern Komponenten
•
Editor –Editoren dienen allgemein zur Texteingabe. Im Falle einer SEU handelt es sich bei dem
Text um den Quellcode. Quellcode-Editoren bieten üblicherweise auch eine Unterstützung zur
Überprüfung der Korrektheit der Syntax an sowie Funktionen zur Verbesserung der Lesbarkeit
des Quellcodes. Die Editoren setzen hierzu Standards um, die die automatische und fehlerfreie
Formatierung des Quelltextes unterstützen, zum Beispiel durch die automatische Einrückung des
Textes oder die automatische Klammerplatzierung. Darüber hinaus kann die Korrektheit der
Syntax durch die automatische Vervollständigung der Syntax erhöht werden, nebenbei reduziert
sich dadurch die Schreibarbeit. Schließlich schaffen Features wie das Ein- und Ausblenden von
Codeblöcken oder das Arrangieren mehrerer Editorfenster mehr Übersichtlichkeit. Im Sinne
einer integrierten SEU kommt vor allem dem Zusammenwirken von Editor und Compiler eine
besondere Bedeutung zu, um z.B. das inkrementelle Compilieren zu ermöglichen.
•
Projekt Manager – Der Projekt Manager unterstützt die Organisation der Informationen und
der einzelnen Artefakte. Er bietet unterschiedliche Sichten (z.B. nach Klassentruktur) und
Filtermöglichkeiten, die vor allem bei umfangreichen Projekten die Übersichtlichkeit steigern.
Typisierte Suchfunktion, z.B. nach Klassen, Methoden und Attributen, erleichtern die sonst
mühsame, textbasierte Suche.
•
Compiler – Heutzutage benötigt der Kompiliervorgang in SEUs nur einen Klick. Bei einigen
SEUs wird der Quellcode fortlaufend im Hintergrund kompiliert, so dass eine sofortige
Fehlererkennung möglich wird. Manche SEUs bieten inkrementelles Übersetzen an, wobei nur
die geänderten Teile des Quellcodes übersetzt werden.
•
Build-Vorgang (Linker) – Die schrittweise, manuelle Erstelleung einer kompletten,
ausführbaren Anwendung ist sehr komplex und aufwändig. Eine SEU verwendet dagegen einen
automatisierten „Buildvorgang“. Dieser Buildvorgang kann durch einen einzigen Maus-Klick
ausgeführt werden.
3
•
Debugging – Um eine Analyse des Programmablaufs durchzuführen, kann ein schrittweises
Debugging eingesetzt werden. Dieses Verfahren ermöglicht die Funktionsweise und die Logik
jeder einzelner Zeile eines Quellcodes zu untersuchen. Eine verteilte Programmierung; bei der
mehrere Teams an einem komplexen Projekt arbeiten, wird von Remote-Debugging unterstützt.
Das Setzen, Entfernen und Auswerten von Haltepunkten im Quellcode wird durch das
Zusammenspiel zwischen Editor und Debugger ermöglicht. Manche SEUs erlauben sogar eine
grafische Darstellung der Werte, Parameter, Variablen usw.
3 Die SEU Code::Blocks (CodeBlocks)
CodeBlocks ist eine integrierte SEU und Open-Source (http://www.codeblocks.org). Als Compiler
unterstützt CodeBlocks unter anderem MinGW (Minimalistic GNU for Windows) Port der GCC
(GNU Compiler Collection). CodeBlocks verfügt über Kernfunktionalitäten zum Editieren,
Navigieren, Kompilieren, Builden und Debuggen.
Die wesentlichen Features der CodeBlocks SEU umfassen:
o die Benutzung GCC-basierter Compiler
o integriertes Debugging
o die Erstellung von Windows- und Console-Anwendungen, Static Libraries und DLLs
o Syntax-Hervorhebung beim Editieren
o Auto-Vervollständiger
o Project Manager inkl. Klassen Browser, Funktionen Auflistung
o Importieren von MSVC- und Dev-C++- Projekten möglich.
3.1 Die Benutzeroberfläche der SEU DevC++
Die im Praktikum zur Verfügung gestellte Version ist CodeBlocks v12.11. Die folgende Abbildung
2 stellt das Startfenster der SEU CodeBlocks dar.
Abbildung 2 CodeBlocks Startfenster
4
Zum erstellen eines neuen Projekts wählt man "Create a new project" aus, dann den Projektypen
(Abb. 3). Hier die gängigsten kurz erwähnt:
• Console application: ein Programm ohne Benutzeroberfläche (GUI). Die Steuerung des
Programmablaufs wird über textbasierte Befehle in eine Kommandozeile durchgeführt.
• Win32 GUI project (für Windows): Die Programme und Dateien werden mit Hilfe
einer grafischen Benutzeroberfläche abgebildet. Diese Benutzeroberfläche kann
Symbole, Menüs oder Dialogfelder beinhalten. Der Benutzer kann diese Elemente mit
der Maus oder über Tastaturbefehle markieren und aktivieren.
• Static Library: Durch den Linker werden statische Bibliotheken nach dem
Kompiliervorgang in einem eigenen Schritt mit dem ausführbaren Programm verbunden.
Diese Bibliotheken beinhalten Funktionen, Klassen oder Ressourcen und können bei
externen Programmen eingebunden werden.
• Dynamic Link Library: Erst bei Bedarf wird eine dynamische Bibliothek in den
Arbeitsspeicher geladen und mit dem ausführbaren Programm verbunden. Eine solche
Bibliothek wird nur einmal im Speicher gehalten.
• OpenGL project: Arbeiten mit erweiterten grafischen Eigenschaften sind hier möglich.
Ein guter Einstieg in die Spieleprogrammierung (für Interessierte ;))
Abbildung 3 DevC++ GUI
Nach Auswahl des Projekttypen folgt ihr einfach den Anweisungen des Wizards. (Typischerweise
fehlt noch die Auswahl der Programmiersprache (C++), des Projektnamens und des Compilers
(Hier einfach bei GNU GCC belassen).
Nach Erstellen des Projekts ist nun links der Workspace mit dem Projekt abgebildet.
Um die "Main"-Methode zu öffnen und mit dem programmieren zu beginnen ist ein Doppelklick
auf „Sources“ und dann auf "main.cpp" nötig.
Die IDE Kernfunktionalitäten die CodeBlocks unterstützt sind in Abbildung 4 dargestellt.
5
Abbildung 4 IDE Kernfunktionalitäten
3.1.1 Grundsätzliche Bedienung
Hier eine kurze Übersicht der wichtigsten Funktionalitäten (Details folgen später)
- Zum erstellen einer neuen Klasse: File → New → Class
Hier optional: Definition von Argumenten, Superklassen, Klassen-Variablen, etc.
- Build and run: Compilieren und Ausführen: Build → Build and run (Taste F9)
- Debuggen: Nach dem setzen von Breakpoints / Haltepunkten:
Zum starten und fortführen nach Breakpoints: Debug → Start/Continue (Taste F8)
und zum abbrechen: Debug → Stop debugger (oder das rote X) (Taste Shift-F8)
6
3.1.2 Der Quellcode-Editor der SEU CodeBlocks
Der in CodeBlocks integrierte Editor bietet Funktionalitäten zum Hervorheben der Syntax, zur
Formatierung des Quellcodes und zur Anordnung mehrerer Editorfenster. Der Editor erkennt
automatisch bestimmte Syntaxtypen und färbt dies entsprechenden Teile des Quellcodes in einer
dem Typ zugeordneten Farbe ein. Beispielsweise wird der Header in Abbildung 5 grün dargestellt
und eine String-Ausgabe in blau. Reservierte Wörter, wie int, return oder if, in dunkleren blau.
Diese Hervorhebung kann unter Settings → Editor → "Syntax highlighting" geändert werden.
Abbildung 5 Editorfenster
Das Zusammenwirken zwischen Editor und Debugger ist durch die Möglichkeit zum Setzen von
Haltepunkten gegeben. Ein Klick zwischen die Zeilennummer und den Zeilenanfang setzt einen
Haltepunkt. Der in Abbildung 5 gesetzte Haltepunkt ist zum Beispiel rot hinterlegt.
Die Formatierung des Quellcodes wird durch eine bedingte Einrückung der darauf folgenden Zeilen
erleichtert. Nach der Eingabe einer Klammer „{“ und der Betätigung der „Enter“ (↵) – Taste wird
diese Einrückung automatisch durchgeführt. Das Anzeigen mehrerer Editorfenster wird Reiterweise realisiert (siehe Abbildung 6).
Abbildung 6 Reiter-weise Anzeige Mehrerer Editor Fenster
CodeBlocks bietet Funktionen zum Ein- oder Ausblenden bestimmter Codeblöcke und liefert
automatische Syntaxvervollständigung.
7
3.1.3 Der Projekt Manager
Der Project-Manager Bereich bietet verschiedene Möglichkeiten und Sichten auf das Projekt an, die
über einzelne Karteikartenreiter auswählbar sind. Über den Reiter „Projects“ erfolgt die Darstellung
aller Artefakte eines Projekts.
Der Projekt Manager Bereich unterstützt:
• den Import und Export von Dateien
• das Erstellen neuer Dateien, Ordner
• das Entfernen von Dateien
• das Setzen der Konfigurationsoptionen des Projekts (über rechten Maus-Klick)
Innerhalb eines Projektes verwaltet CodeBlocks sämtliche Quellcode Dateien.
3.1.4 Compiler, Debugger und Builder
Die Werkzeuge Compiler, Debugger und Builder sind über die Benutzeroberfläche durch eigene
Symbole auswählbar.
startet den Compiliervorgang und startet anschließend das Programm.
startet das Debuggen / setzt das Debuggen nach einem Breakpoint fort.
stoppt / bricht das Debuggen ab.
Der Compiler in CodeBlocks wird nur aktiv sobald der Compiler-Button betätigt wird. Das
Zusammenwirken zwischen Debugger und Editor ermöglicht beim Auftreten eines Fehlers durch
Doppel-Klicken auf den gefundenen Fehler im Logfenster (siehe Abbildung 6), den Wechsel in das
Editorfenster in dem die Zeile die den Fehler enthält farbig hervorgehoben ist.
Abbildung 6 Logfenster
Bedienung und Sinn des Debuggers:
- Der Debugger dient dazu den eigenen Programmablauf nachzuvollziehen wenn man z.B.
einen Fehler vermutet. Durch die Verfolgung des Codes mit dem Debugger können
individuelle Code-Abschnitte untersucht werden.
- Durch setzen von Breakpoints / Haltepunkten (Abb. 5) kann man dem Programmablauf
folgen, während jeweils bei den Haltepunkten pausiert wird. Ein setzen von
Haltepunkten ist z.B. sinnvoll wenn man dort einen Fehler vermutet oder wenn man sich
die Iterationen einer Schleife anschauen möchte.
- Zur besseren Programmablaufverfolgung können mehrere Haltepunkte gesetzt werden.
- Um die Werteveränderungen von Variablen zu verfolgen muss zusätzlich folgendes
Fenster geöffnet werden: Debug → Debugging Windows → Watches
8
4.
Praktische Übungen
Die folgenden praktischen Übungen sind von den Studierenden während der ersten beiden
Praktikumstermine zu bearbeiten. Sie sollen in die Benutzung der SEU CodeBlocks
einführen und einen Überblick über die bereitgestellten Funktionen und
Unterstützungsmöglichkeiten geben. Weitere eigene Übungen sind möglich und
wünschenswert um sowohl die Bedienung der Entwicklungsumgebung zu üben, deren
Funktionsumfang zu erproben oder einfach um die eigenen Programmierkenntnisse
aufzufrischen und zu vertiefen.
4.1 Erstellen eines Projektes.
Erstellen Sie ein neues Projekt ("Console Application") mit dem Namen "Test-C-Projekt-1"
und speichern sie es in einem Verzeichnis "TestProjekt1".
4.1a Wo haben sie das Verzeichnis "TestProjekt1" erzeugt?
_________________________________________________________
4.1b Welche Dateinamenerweiterung hat die Datei "Test-C-Projekt-1"?
_________________________________________________________
4.2. Erzeugen und Hinzufügen einer neuen Datei.
Erstellen Sie eine neue Datei mit dem Namen "hello.cpp" manuell im Projektverzeichnis und
fügen Sie diese acnschließend Ihrem Projekt hinzu. Löschen Sie dazu die automatisch
generierte Datei "main.cpp".
4.2a Welchen Namen hat CodeBlocks standardmäßig nach dem Erzeugen einer neuen Datei
dem Reiter Editor vergeben?
_________________________________________________________
4.2b Was müssen sie tun um den standardmäßig vergebenen Namen umzubenennen?
_________________________________________________________
_________________________________________________________
4.2c Erstellen Sie nun eine Klasse mithilfe von CodeBlocks (File → New → ). Was
unterscheidet sich? Ist dies sinnvoller?
_________________________________________________________
_________________________________________________________
4.3 Syntax Eingabe.
Geben Sie folgenden Programmcode im Editor Fenster ein:
#include<stdio.h>
#include<conio.h>
int main ()
{
printf (“Hello There! I’m back!!\n”);
getch();
}
9
4.4 Programm Ausführung.
4.4a Speichern Sie das gesamte Projekt. Welche Dateien existieren und wo sind sie
gespeichert?
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
4.4b Führen Sie nun das Programm aus. Notieren Sie die hierfür nötigen Schritte.
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
4.4c Sehen Sie sich die Projekt Optionen und die Compiler Einstellungen an. Verändern Sie
einzelne Einstellungen und notieren sie deren Einfluss auf die Programmausführung.
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
4.5 Fehlersuche
Gegeben sei das folgende Programm.
#include<stdio.h>
void main(void)
{
char Name[25];
printf("Hello! What's your name ? );
gets(Name)
printf("\nWhat's your favourite colour? ");
gets(Color);
printf("\n%i's favourite colour is %s \n", Name, Color);
getch();
}
4.5a. Erstellen Sie ein neues Projekt, bzw. eine neue Datei mit dem oben gezeigten Quelltext
und compilieren Sie diese. Wie viele Fehler haben Sie festgestellt und wie lautet die
richtige Syntax?
10
4.5b Speichern Sie die Datei erneut und setzen Sie Haltepunkte an folgenden Zeilen:
gets(Name) und gets(Color). Führen Sie das Programm aus. Was ist der Unterschied
zwischen "Continue" und "Next line"?
4.5c Entfernen Sie die Haltepunkte von 4.5b. Benutzen Sie "Run to cursor" als Haltepunkt,
setzen Sie den Cursor an der Zeile gets(Color). Führen Sie das Programm noch einmal
aus. Was passiert und was ist die Funktion?
11
4.6 Programmieraufgaben – Multi-Threading mit C
Echtzeitsystemen sind dadurch charakterisiert dass sie ihre Aufgaben in vorgegebenen
Zeitschranken lösen müssen. Dadurch entsteht oftmals der Bedarf, dass mehrere Aufgaben parallel
ausgeführt werden müssen. Dies ist zum Beispiel dann der Fall, wenn ein System komplexe
Berechnungen durchführen muss und dabei gleichzeitig auf Benutzereingaben oder andere
Ereignisse reagieren soll.
Zur Implementation der benötigten Parallelverarbeitung gibt es verschiedene Möglichkeiten.
Mehrere Prozessoren
Verteilung der Prozesse auf mehrere Prozessoren, die diese Prozesse dann parallel verarbeiten. In
diesem Fall spricht man auch von "echter" Parallelität oder Hardwareparallelität. Diese Variante ist
Teuer und nicht für alle Aufgabenstellungen angemessen.
Hinweis: Die Core 2 Duo Technologie von Intel basiert basiert auf dem beschriebenen Prinzip.
Multi-Tasking
Multi-Tasking Systeme bieten eine günstige und effiziente Alternative zum Einsatz mehrerer
Prozessoren. Bei einem Multitasking System wird die Rechenzeit eines einzelnen Prozessors -unter
Einhaltung der Echtzeitbedingungen- auf alle zur Verarbeitung anstehenden Prozesse aufgeteilt.
Zusätzlich können für die einzelnen Prozesse Prioritäten vergeben werden und so die Verteilung der
Rechenzeit zusätzlich beeinflusst werden. Die Prozesse können unabhängig voneinander ausgeführt
werden, da Sie auf verschiedene Ressourcen (Adressraüme) zugreifen.
Multi-Threading
Eine weitere Alternative besteht darin, Ausführungspfade einzelner Prozesse voneinander zu
trennen, um diese parallel ausführen zu können. Die sogenannte Threads, auch Light Weight
Processes (LWG) genannt, können sich im Gegenteil zu Prozessen den gleichen Adressraum teilen.
So werden unnötige Speicherzugriffe und die aufwändige Interprozess-Kommunikationen. Eine
feinere Granulierung der Ausführungseinheiten ermöglich dem Betriebssystem zusätzlich eine
effizientere Verwaltung der Ressourcen, weil Threads, ähnlich wie bei Prozessen, auch auf mehrere
Prozessoren verteilt werden können.
Anmerkung: Im Rahmen des Praktikums kann der Einsatz von Multi-threading bei der
Programmierung der Aufzugssteuerung sinnvoll sein
4.6.1 Aufgabenstellung
Das Ziel dieser Aufgabe ist die Realisierung einer Aufgabe mit Multi-threading.
Erstellen Sie zuerst einen Rechteck. Innerhalb dieses Rechtecks platzieren sie ein weiteres Objekt,
z.B. ein kleineres Rechteck. Durch das Drücken der Tasten ↑, →, ↓, oder ← ändern Sie die Position
des Objekts innerhalb des Rechtecks in die entsprechende Richtung.
Eine mögliche
Programmierrealisierung könnte wie folgt aussehen:
12
Abbildung 7 Programmbeispiel
Für diese Aufgabe sind zwei Threads zu erstellen. Ein Thread wird für die Steuerung des Objekts
benötigt, und ein Thread zur Entgegennahme und Verarbeitung der Tastatureingaben.
5. Weiterführende Quellen
Code::Blocks Resource Site: http://www.codeblocks.org/
GNUs GPL (General Public License): http://www.gnu.org/copyleft/gpl.html
13