10 Modulares Programmieren

Transkript

1 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 51 von Modulares Programmieren Was ist ein Modul? Ein Programmteil, der getrennt entworfen, implementiert und getestet werden kann Eine selbständig übersetzbare Programmeinheit Enthält vorübersetzte Programmobjekte, die beim binden zu einem Programm hinzugefügt werden können Globale Objekte werden nach Außen zu Verfügung gestellt Export-Schnittstelle Modulimplementierung Import-Schnittstelle Objekte aus anderen Modulen werden benutzt Ein Modul enthält lokal definierte oder global definierte Programmobjekte Global definierte Programmobjekte können in anderen Modulen verwendet werden ( das Modul exportiert diese globalen Programmobjekte nach Außen). Exportiert werden können nur global definierte Programmobjekte. Lokale Programmobjekte sind nur innerhalb des Moduls verfügbar. Exportierbare Programmobjekte sind: Funktionen/Prozeduren Variablen Datentypen Konstanten Ein Modul importiert extern definierte Programmobjekte, wenn es Bezeichner verwendet, die in anderen Modulen global definiert, also exportiert werden. Ein Modul kann demnach sowohl Programmobjekte exportieren als auch externe Programmobjekte importieren. Die Menge aller global vereinbarten Programmobjekte eines Moduls bestimmen die EXPORT- Schnittstelle des Moduls. Die Menge aller von fremden Modulen benutzter Programmobjekte ergibt die IMPORT-Schnittstelle des Moduls.

2 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 52 von 73 Ein Modul hat folgenden generellen Aufbau: Modulname Textuelle Modulbeschreibung Schnittstellenbeschreibung Liste importierter Objekte Deklaration exportierter Objekte Implementierung Definition globaler Variablen Implementierung von Funktionen / Prozeduren Modulname ist in der Regel der Dateiname. Die textuelle Beschreibung dient dazu, dem Anwender eine lesbare Beschreibung der Modulinhalte zu Verfügung zu stellen. Dieser Abschnitt ist Kommentartext, der nicht vom Compiler übersetzt wird. Diese Kommentare werden normalerweise in der Form von vorgefertigten Formularen, den Modulheadern, verwendet. Beispiel für solche Modulheader sind beim Modul STACK in diesem Kapitel angegeben. Schnittstellenbeschreibung und Implementierung sind Programmiersprachenelemente, die vom Compiler übersetzt werden. Im Teil Implementierung werden alle exportierten Programmobjekte definiert und konkret ausprogrammiert. Der Entwurf eines Moduls kann nach unterschiedlichen Gesichtspunkten erfolgen: funktionell Alle Funktionen, Prozeduren und Daten realisieren einen Arbeitsvorgang datenorientiert Alle Funktionen und Prozeduren bearbeiten dieselben Datenobjekte. Funktionen / Prozeduren und Datenobjekte sind gekapselt. Diese Art führt zu den abstakten Datenobjekten ( ADO ). organisatorisch Das Modul enthält alle Objekte eines Programmierers

3 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 53 von MODULHIERARCHIE EINES P ROGRAMMS Ein Programm wird durch Module hierarchisch in mehrere Ebenen strukturiert. Beispiel Hauptprogramm Ebene > benutzt Objekte aus Modul A Ebene > benutzt Objekte aus Modul B Ebene > benutzt Objekte aus Modul C und D Ebene 3 Diese Hierarchie wird durch die folgende Grafik beschrieben: HP HP benutzt keine Objekte aus C A B Modul B benutzt ( importiert ) Objekte aus C C D Entwurf eines modularen Programms am Beispiel Iteratives Umdrehen von Buchstaben Nach datenorientierten Gesichtspunkten kann das Problem in zwei Programmmodule zerlegt werden: ein Modul HAUPT Dieses enthält das Hauptprogramm und übernimmt das Umdrehen der Zeichen eines Wortes. Das Modul enthält damit die Funktion main(), die nach außen exportiert wird. Das Modul importiert Objekte aus dem Modul STACK und den Standardbibliotheken ( scanf, printf ). ein Modul STACK Dieses Modul enthält alle Programmobjekte, die zur Realisierung des Stack benötigt werden. Exportierte Programmobjekte sind die Funktionen zum Zugriff auf den Stack ( initstack, push, pop ). Der Stack selbst wird dynamisch realisiert. Zugriff auf die Stackelemente erfogt über den Stackzeiger, der auf eine verkettete verweist. Der Stackzeiger wird als modulglobale Variable definiert und wird daher nicht exportiert. Im Modul werden Objekte aus den Standardbibliotheken importiert ( malloc, free ).

4 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 54 von 73 Aufbau des Moduls STACK Modulname: STACK Modulbeschreibung: Das Modul realisiert einen dynamischen Stack. Schnittstellenbeschreibung Import: Funktionen malloc() und free() aus dem Modul stdlib Export: Definiton der Konstanten STACK_LEER ( in der Headerdatei stack.h ) Funktionen: initstack(), push(), pop() Implementierung: Definition des modulglobalen Datentyps STACKELEMENT Definition der modulglobalen Variablen stackzeiger vom Datentyp STACKELEMENT Definition der globalen Funktionen: initstack() push() pop() Um Objekte aus fremden Modulen benutzen zu können muß von dem fremden Modul eine Schnittstellenbeschreibung vorliegen. In dieser Schnittstellenbeschreibung wird angegeben: welche Programmobjekte nach Außen zu Verfügung gestellt werden ( EXPORT-Liste ) Eine textuelle Beschreibung was die Programmobjekte bedeuten oder was sie tun Eine Beschreibung der Syntax ( Prototypen ), damit sie im Programm korrekt verwendet werden können. Die Schnittstellenbeschreibung wird in C über Headerdateien realisiert. Zu jedem Modul wird eine Headerdatei angelegt, in der alle globalen Datentypen, Konstanten und die Prototypen der Funktionen liegen. Diese Headerdatei wird im Modul STACK und allen Modulen, die Objekte aus STACK verwenden mit #include eingefügt. Zusätzlich wird eine textuelle Beschreibung erstellt, die die Bedeutung der Programmobjekte erklärt. Solche textuellen Beschreibungen werden in der Regel in Form von Formularen, den Modulheadern und den Funktionsheadern als lesbarer Kommentartext zu Verfügung gestellt. Die Modulhierarchie für das Beispiel: HAUPT STACK stdlib stdio

5 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 55 von 73 Schnittstelle und Implementierung des Moduls Stack Headerdatei stack.h /******************************************************************/ /* Export-Schnittstelle des Moduls stack ( stack.h ) */ /******************************************************************/ /* Makros und Konstanten */ #define STACK_LEER 0 /* Funktionsprototypen */ extern int initstack(void); extern void push( char zeichen ); extern char pop(void); Quelldatei stack.c /************************************************************************/ /* MODULHEADER */ /************************************************************************/ /* Projekt: WorteUmdrehen */ /* Modulname: stack.c */ /* Versionsnummer: 1.0 */ /* Modultyp: Abstraktes Datenobjekt ( ADO ) */ /* Sprache/Compiler: Borland C++, 5.0 */ /* Kurzbeschreibung: Das Modul realisiert einen Zeichen-Stack */ /* Export Elemente: Konstante: STACK_LEER */ /* Funktionen: initstack(), push(), pop() */ /* Import Elemente: */ /* Aus Modul stdio: Konstante : NULL */ /* Modul stdlib: Funktionen: malloc(), free() */ /* Ersteller/Fach: Stud1/Prog2 */ /* Erstellungsdatum: 15. Juni 1998 */ /* letzte Aenderung: 16. Juni 1998 */ /* Import-Schnittstelle des Moduls */ #include <stdio.h> #include <stdlib.h> /* Export-Schnittstelle des Moduls stack */ #include "stack.h"

6 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 56 von 73 /******************************************************************/ /* Implementierung des Moduls */ /******************************************************************/ /* Modulglobale Datentypen und Variablen */ typedef struct stackelement { struct stackelement *next; char zeichen; } STACKELEMENT; static STACKELEMENT *stackzeiger; /* FUNKTIONS-HEADER globaler Funktionen */ /* Funktion: int initstack(void) */ /* Kurzbeschreibung: Initialisiert den Stack auf leer */ /* Ergebnis: STACK_LEER */ /* Import-Parameter: keine */ /* Export-Parameter: keine */ /* modulglobale Variablen: stackzeiger */ int initstack(void) { stackzeiger = NULL; /* Importiert NULL aus stdio */ return STACK_LEER; } /* Funktion: void push(char zeichen) */ /* Kurzbeschreibung: Legt ein Zeichen auf den Stack */ /* Ergebnis: keines */ /* Import-Parameter: zeichen */ /* Export-Parameter: keine */ /* Modulglobale Variablen: stackzeiger */ /************************************************************************/ void push( char zeichen ) { STACKELEMENT *objektzeiger; /* Importiert malloc aus stdlib */ } objektzeiger=(stackelement *) malloc(sizeof(stackelement)); objektzeiger->next=stackzeiger; objektzeiger->zeichen=zeichen; stackzeiger=objektzeiger;

7 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 57 von 73 /* Funktion: char pop(void) */ /* Kurzbeschreibung: Holt ein Zeichen vom Stack */ /* Ergebnis: Das oberste Zeichen vom Stack oder STACK_LEER */ /* Import-Parameter: keine */ /* Export-Parameter: keine */ /* Modulglobale Variablen: stackzeiger */ /**********************************************************************/ char pop(void) /* Entfernt oberstes Element vom Stack. */ /* Falls der Stack leer ist das Ergebnis 0 */ { char zeichen; STACKELEMENT *hilf; /* sonst das entfernte zeichen */ } if ( stackzeiger!= NULL ) { zeichen=stackzeiger->zeichen; hilf = stackzeiger; stackzeiger=stackzeiger->next; free(hilf); /* Importiert free aus stdlib */ } else zeichen=stack_leer; return zeichen;

8 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 58 von 73 I MPLEMENTIERUNG DES M ODUL HAUPT /************************************************************************/ /* MODULHEADER */ /************************************************************************/ /* Projekt: WorteUmdrehen */ /* Modulname: haupt.c */ /* Versionsnummer: 1.0 */ /* Modultyp: Abstraktes Datenobjekt ( ADO ) */ /* Sprache/Compiler: Borland C++, 5.0 */ /* Kurzbeschreibung: Das Programm vertauscht die Buchstaben eines */ /* eingegeben Wortes */ /* Export Elemente: Funktionen: main() */ /* Import Elemente: */ /* Aus Modul stdio: Funktionen: scanf(), printf() */ /* Modul stack: Funktionen: initstack() */ /* push(), pop() */ /* Konstante : STACK_LEER */ /* Ersteller/Fach: Stud1/Prog2 */ /* Erstellungsdatum: 15. Juni 1998 */ /* letzte Aenderung: 16. Juni 1998 */ /* Import-Schnittstelle des Moduls */ #include <stdio.h> #include "stack.h" /* Implementierung des Moduls */ /* Modulglobale Makros und Konstanten definieren */ #define NEWLINE '\n' #define BLANK ' ' /* FUNKTIONS-HEADER */ /* Funktion: int main(void) */ /* Kurzbeschreibung: Hauptprogramm zum Umdrehen eines Wortes */ /* Ergebnis: in jedem Fall 0 */ /* Import-Parameter: keine */ /* Export-Parameter: keine */

9 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 59 von 73 int main(void) { char zeichen; /* Lokale Variable */ initstack(); /* Import von initstack() */ do /* Einlesen des Wortes und Aufbau des Stack */ { scanf("%c",&zeichen); /* Import von scanf */ push(zeichen); /* Import von push */ } while (zeichen!= BLANK && zeichen!= NEWLINE ); printf("umdrehen\n"); /* Import von printf */ do /* Ausgabe des Wortes und Abbau des Stack */ { zeichen=pop(); /* Import von pop */ if ( zeichen!= STACK_LEER ) printf("%c",zeichen); } while ( zeichen!= STACK_LEER); } return 0;

10 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 60 von E RZEUGEN EINES MODULAREN P ROGRAMMS Erstellung modularer Programme Prof. Dr. - Ing. S.Keller FH Ravensburg-Weingarten Angewandte Informatik Haupt.c Stack.h stdio.h Übersetzen Stack.c Übersetzen Exportschnittstelle von stack Stack.h Headerdateien zu vorübersetzten Programmobjekten stdio.h stdlib.h Mit #include-anweisung Haupt.o Vorübersetzte Programmobjekte Stack.o Binden Vorübersetzte Programmobjekte in Systembibliotheken Stdio stdlib wortumdrehen Übersetzten,Binden Um ein lauffähiges Programm zu erzeugen müssen alle Module des Programms einzeln in Programmobjekte übersetzt werden Diese Programmobjekte müssen dann durch den Binder ( Linker ) zu einem lauffähigen Programm zusammengefügt ( gebunden ) werden. Beispiel UNIX: Der C-Compiler unter UNIX ruft nach dem Übersetzen von C-Sourcedateien xxx.c in Objekte xxx.o automatisch den Binder ( link editor: ld ) auf um damit ein ausführbares Programm mit dem Namen a.out zu erzeugen. Duch das Kommando cc haupt.c stack.c wird unter UNIX ein lauffähiges Programm mit dem Namen a.out erzeugt. Die Kommandosyntax für den Aufruf des C-Compilers unter UNIX lautet: $ cc [Optionen]... file... [Option... file ]... [ -link[link-libraryinfo] ] [] bedeutet: Diese Angaben sind wahlweise und können weggelassen werden. In diesem Fall werden Standardwerte genommen. ' file ' muss angegeben werden und kann sein: xxx.c : xxx.o : xxx.a : eine C-Quelletextdatei. Diese wird in ein Objekt übersetzt eine vorübersetzte Objektdatei. Diese wird nicht übersetzt sondern nur zum ausführbaren Programm dazugebunden eine Bibliothek mit vorübersetzten Programmobjekten; diese wird beim Binden nach Referenzen durchsucht Falls die Extension.c,.o oder.a fehlt, nimmt der C-Compiler an es handelt sich um eine Objektdatei

11 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 61 von 73 Optionen für Ihre Programme: -o outfile Ausführbares Programm wird mit dem Namen outfile erzeuget. Ohne diese Option erzeugt der Compiler automatisch ein ausführbares Programm mit dem Namen a.out. -c Nur vorübersetzte Objekte erzeugen, aber nicht binden Beispiele: $ cc a.c b.c d.o e.o Übersetzen von a.c und b.c in Objekte a.o und b.o; Danach binden von a.o, b.o, d.o und e.o zum ausführbaren Programm a.out $ cc a.o b.o Es wird kein C-Modul übersetzt. Der Compiler ruft direkt den Binder ld auf, der die Objekte a.o und b.o zu einem ausführbaren Programm a.out bindet Erzeugen eines modularen Programms Einstufig: $ cc -O modul1.c modul2.c modul3.c -o progname Zweistufig: $ cc -Oc modul1.c modul2.c modul3.c ( Nur Übersetzen ) $ cc modul1 modul2 modul3 -o progname ( Nur Binden ) Das UNIX-Werkzeug Make MAKE ist ein Werkzeug zur automatischen Erzeugung modularer Programme ( Projekte ). Aus welchen Modulen sich ein Programm zusammensetzt wird durch Dateiabhängigkeiten erklärt. Ob ein Programm in einer aktuellen Version vorliegt ist erkennbar an der Zeit der letzen Änderung von Sourcedatei und Programm. Die Abhängigkeiten eines ausführbaren Programms ( Sourcedatei, Headerdatei, Objektdatei, Bibliotheken ) als auch die Aktionen die auszuführen sind, um aktuelle Objekte ( Dateien ) zu erzeugen werden in Form von Regeln in einer Beschreibungsdatei mit dem Namen makefile erklärt. Zum Aktualisieren oder Erzeugen eines Programms ruft man das UNIX-Werkzeug make mit dem zu erzeugenden Objekt als Parameter auf. Make ermittelt aus dem Beschreibungfile alle Abhängigkeiten des Objektes und die notwendigen Kommandos zur Erzeugung des Objektes. Existiert das angegebene Objekt noch nicht werden entsprechend dem Abhängigkeitsbaum ( siehe Bild ) alle Objektdateien erzeugt und zu einem ausfühbaren Programm gebunden. Existiert das Objekt, so erkennt make an dem Datum der letzten Änderung, wenn eine oder mehrere Sourcedateien ( Headerdateien ) geändert wurden und damit das Objekt nicht mehr aktuell ist Es werden dann automatisch nur diese Dateien übersetzt, die ein jüngeres Datum als das ausführbare Programm haben und eine aktuelle Version des Objektes erzeugt. Make kennt fest eingebaute Regeln, die die Abhängigkeiten von Sourcedateien, Objektdateien und ausführbarem Programm und die Kommandos zu deren Erzeugung beschreiben. Existiert kein makefile oder enthält ein makefile keine Regeln so werden automatisch die eingebauten Regeln genommen. Findet make eine Regel im makefile so wird jedoch diese und nicht die eingebaute Regel genommen. Make erlaubt es, Texte im makefile, die man mehrfach verwenden möchte, unter einem Namen als MAKRO zusammenzufassen. Durch Aufrufen eines Makros werden dann diese Texte im makefile eingefügt ( Makroexpansion). Neben fest eingebauten Regeln sind auch Macros in make vordefiniert Es ist auch möglich Namen für Regeln zu definieren, die kein ausführbares Programm beschreiben, sondern lediglich eine Folge von Kommandos, die einen häufig vorkommenden Vorgang beschreiben.

12 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 62 von SYNTAX DER B ESCHREIBUNGSDATEI Kommentarzeile: Erzeugen von Fortsetzungszeilen: Regel: Makrodefinition: Makroaufruf: # Text '\' am Ende der Zeile zeigt an, daß eine Fortsetzungszeile folgt Objekt1... Objektn : [:] Abhängigkeit1... Abhängigkeitk \t Kommando \t Kommando Makroname = Text $Makroname, falls Name nur ein Zeichen lang $(Makroname), falls Makroname mehr als ein Zeichen lang Vordefinierte Dateiextensions ( SUFFIXES ):.o.c Vordefinierte Makros: $@ Voller Pfadname des aktuell zu erzeugenden Objektes. $< Name der Datei, die ein jüngeres Datum als das zu erzeugende Objekt besitzt und damit die Kommandoausführung auslöst. Wird nur bei nicht explizit angegeben Abhängigkeiten durch Abhängigkeitsregeln expandiert $* Name ohne Extension der aktuellen abhängigen Datei, die auch Zielobjekt ist. Wird nur bei nicht explizit angegeben Abhängigkeiten durch Abhängigkeitsregeln expandiert $? Zeichenketter aller Namen, die jünger sind als das Objekt LDFLAGS = Optionen des Binders ld CFLAGS = -O C-Compiler Optionen CC = cc Name des C-Compilers ARFLAGS = rv Optionen des Programms zum Erzeugen von Modulbibliotheken AR = ar Name des Programms zur Erzeugung von Biblitheken Vordefinierte Abhängigkeits-Regeln:.c.a:.c.o:.c: $(CC) -c $(CFLAGS) $< $(AR) $(ARFLAGS) $@ $*.o rm -f $*.o $(CC) $(CFLAGS) -c $< $(CC) $(CFLAGS) $< $(LDFLAGS) -o $@

13 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 63 von BEIPIEL FÜR DAS MAKEFILE ZUR E RZEUGUNG DES AUSFÜHRBAREN P ROGRAMMS W ORTEU MDREHEN UND EINER R EGEL MIT N AMEN CLEAN Die Abhängigkeiten und notwendige Aktionen beschreibt das folgende Bild: WorteUmdrehen cc haupt stack -o WorteUmdrehen haupt.o stack.o cc -c haupt.c cc -c stack.c haupt.c stack.c tue nichts stack.h Inhalt von "makefile" # Regel WorteUmdrehen beschreibt die Abhängigkeiten von WorteUmdrehen # und die UNIX-Kommandos zur Erzeugung von WorteUmdrehen # Die erste Zeile beschreibt das zu erzeugende Objekt. Nach dem Doppelpunkt # sind alle Abhängigkeiten aufgelistet. Die zweite Zeile beschreibt das # Kommando, durch welches das Objekt aus seinen Abhängigkeiten erzeugt wird. WorteUmdrehen: haupt.o stack.o cc haupt.o stack.o -o WorteUmdrehen # Diese Regelen beschreiben die Abhängigkeiten von haupt.o und stack.o # und das Kommando zur Erzeugung der beiden Objekte haupt.o: haupt.c stack.h cc -c haupt.c stack.o: stack.c stack.h cc -c stack.c # Regel mit Namen clean zum Aufräumen des Plattenspeichers. Alle Objekte # werden gelöscht. clean: rm *.o Kommandoeingabe zur Ausführung der Regeln make WorteUmdrehen make clean Erzeugt das lauffaähige Programm "foo" Aufräumen auf Plattenspeicher

14 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 64 von KOMMANDOSYNTAX $ make [Optionen] [Makrodefinitionen] [Objekt/Regel] Optionen: -r keine eingebauten Regeln verwenden -n Anzeigen aller auszuführenden Kommandos ohne die Aktionen tatsächlich auszuführen.( Kontrollausgabe ) -t Aktualisiert das Datum der Zielobjekte anstatt die Kommandos auszuführen -s Ausführen der Kommandos ohne Kontrollausgaben -f filename Beschreibungsfile hat Namen filename anstatt makefile Makrodefinitionen: Ersetzen intern definierte Makros Objekt/Regel: Objekt ist ein zu erzeugendes abhängiges Objekt oder der Name einer Regel unter der bestimmte Kommandos auszuführen sind.

15 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 65 von M ODULTYPEN Zur Strukturierung eines Programms sollten nur Module entsprechend den folgenden vier Modultypen entworfen und implementiert werden. Module, die beispielsweise globale Daten und Funktionen enthalten sollte es nicht geben. In diesem Fall muss dann das Programm zwei Module enthalten, ein Modul vom Typ GLOBALE DATEN und ein Modul vom Typ FUNKTIONSBOBLIOTHEK. Modultypen Prof. Dr. - Ing. S.Keller FH Ravensburg-Weingarten Angewandte Informatik Schnittstelle Prototypen Konstanten Modul ( Implementierung ) Funktionsbibliothek Funktion 3 Funktion Lokale Daten 2 Funktion Lokale Daten 1 Lokale Daten Ankündigung externer Datenobjekte Konstanten, Datentypen Globale Daten Daten Prototypen Konstanten Datentypen Abstraktes Datenobjekt ModulDaten ZF1 ZF2 ZF3 Konstanten Datentypen Das Modul exportiert nur Funktionen Es enthält weder globale noch modulglobale Daten Das Modul exportiert nur globale Daten Es enthält keine Funktionen Das Modul exportiert nur Sonderfall Funktionen Es existiert kein Es enthält keine globalen Daten, vorübersetztes dafür aber modulglobale Daten Objektmodul Der Zugriff von anderen Modulen auf diese Daten erfolgt über die Funktionen Symbol M ODULTYP F UNKTIONSBIBLIOTHEK Eine Funktionsbibliothek enthält eine Sammlung von Funktionen, die man semantisch gruppieren möchte z.b. eine Sammlung mathematischer Funktionen in einem Modul mit Namen MATH oder Funktionen zur grafischen Ausgabe in einem Modul mit Namen GRAPHICS. Das Modul exportiert nur Funktionen, Es enthält weder globale noch modulglobale Daten. IMPLEMENTIERUNG: Im Modul dürfen nur Funktionen mit lokalen Variablen definiert werden. Die Definition zusätzlicher lokaler Funktionen, die selbst nicht exportiert werden, ist erlaubt. Lokale Funktionen sind Funktionen, die nur im Modul gültig sind und damit von allen Funktionen im Modul verwendet werden können aber nicht von Funktionen in externen Modulen. Bei der Definition muss die Funktion mit dem Schlüsselwort static gekennzeichnet sein. Beispiel: static int add(inta, int b) { return a+b;}

16 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 66 von 73 SCHNITTSTELLE: Die Schnittstelle wird in einer Headerdatei mit gleichem Modulnamen aber der Dateikennung.h ( <modulname>.h ) festgelegt. Die Schnittstelle enthält die Prototypen aller exportierten Funktionen sowie benötigter Konstanten Will ein externes Modul A Funktionen aus der Funktionsbibliothek FB importieren muss in A die Schnittstelle ( Headerdatei ) mit #include FB.h eingebunden werden. M ODULTYP G OBALE D ATEN Das Modul exportiert global vereinbarte Daten und damit verbundene Konstanten und Datentypen, die in anderen externen Modulen benutzt werden sollen. IMPLEMENTIERUNG: Es dürfen nur globale Daten definiert werden. Initialwerte sind bei der Definition anzugeben. Modulglobale Daten sowie Funktionen dürfen nicht vorkommen. ( Da in dem Modul nur Variablen definiert werden, liegt die Definition immer außerhalb einer Funktion und ist damit global ) BEISPIEL: meintyp daten = INITIALWERT; SCHNITTSTELLE: Die Schnittstelle wird in einer Headerdatei mit gleichem Modulnamen aber der Dateikennung.h definiert. Die Schnittstelle kündigt die Verwendung extern definierter Variablen an. Dies geschieht durch die Deklaration einer Variablen mit dem Schlüsselwort extern. Die Vergabe von Initialwerten in der Headerdatei ist verboten. Initialisiert wird die Variable im Implementierungsteil des Moduls. Die Schnittstelle enthält alle zu exportierenden Konstantenwerte und Datentypen BEISPIEL: #define INITIALWERT 10 /* Konstante */ typedef unsigned int meintyp; /* Datentyp*/ extern meintyp daten; /* Ankündigung der externen Variablen */ Will ein externes Modul A auf die globalen Variablen im Modul G zugreifen, muss in A die Schnittstelle ( Headerdatei ) mit Schnittstelle: globaledaten.h #include G.h eingebunden werden. #define Initialwert 10 typedef unsigned int meintyp extern meintyp daten: Modul: globaledaten.c typedef unsigned int meintyp; meintyp daten =10; Modul: A #include globaledaten.h daten = daten * 2; #include globaledaten.h meinwert = daten;

17 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 67 von 73 M ODULTYP A BSTRAKTES D ATENOBJEKT ( ADO ) Das Modul enthält modulglobale Daten,die nicht exportiert werden. Über Funktionen, die als einzige Objekte exportiert werden, kann man auf diese Variablen zugreifen ( lesen, ändern, schreiben ). Durch die modulglobalen Daten mit langfristiger Lebensdauer hat das Modul einen inneren Zustand. ANWENDUNG UND VORTEILE: Der Zugriff auf Daten, die in mehreren Modulen benötigt werden und damit global vereinbart werden müssten, wird durch ein Modul überwacht. Der Zugriff von externen Modulen auf die Daten erfolgt nicht direkt, sondern indirekt über Funktionen, die das Modul bereitstellt. Dadurch werden Programmierfehler minimiert. Die Pflege des Programms wird einfacher, da nur ein Programmierer für Ergänzungen und Änderungen zuständig ist. Die Art und Weise wie komplexe Datenstrukturen im Programm realisiert sind bleibt den Anwendern verborgen ( information hiding ). Sie wird durch den Programmier, der für das Modul zuständig ist, festgelegt Über Funktionen im Modul wird die Bearbeitung der Daten überwacht. Man kann sehr einfach die Realisierung der Datenstruktur ändern ohne das andere Module d.h. Programmierer betroffen sind, in dem man die Funktionsschnittstelle ( Funktionsname, Ergebnistyp und formale Parameter ) unverändert lässt. BEISPIEL: REALISIERUNG EINES STACK. Der Stack wird als modulglobale Variable realisiert. Über die Funktionen init(), push() und pop() wird der Stack verändert. Durch diese drei Funktionen ist der Stack als abstrakte Datenstruktur eindeutig beschrieben. Egal wie der Stack als Variable realisiert wird ( als array oder als verkettete Liste ), die Funktionen bleiben gleich und haben immer die gleiche Wirkung. Der Programmierer, der den Stack verwendet, muß nur diese Funktionen nicht aber die Realisierung des Stack kennen. Man kann die Implementierung des Stacks im Modul ändern z.b. von array-realisierung zu einer einfach verketteten Liste ohne das andere Programmierer davon betroffen sind. IMPLEMENTIERUNG: Im Modul dürfen nur modulglobale Daten und Funktionen definiert werden. Globale Daten sind nicht erlaubt. Modulglobale Variablen werden wie globale Variablen ausserhalb einer Funktion definiert und mit Initialwerten versehen. Durch das Schlüsselwort static wiird die Gültigkeit der Variablen auf das Modul eingeschränkt. Die Variablen werden damit nicht mehr exportiert. BEISPIEL: static int stack[256]={0}; static int stackzeiger=0;

18 Programmieren 2 Prof. Dr. Keller Studiengang Angewandte Informatik Ausgabe: Seite 68 von 73 SCHNITTSTELLE: Die Schnittstelle wird in einer Headerdatei mit gleichem Modulnamen aber der Dateikennung.h definiert. Die Schnittstelle enthält die Prototypen der exportierten Funktionen sowie alle zu exportierenden Konstantenwerte und Datentypen Will ein externes Modul A über die Funktionen auf die modulglobalen Daten im Modul ADO zugreifen muss in A die Schnittstelle ( Headerdatei ) mit #include ADO.h eingebunden werden. M ODULTYP MAK RO Als Sonderform von Modul kann in C der Modultyp MACRO betrachtet werden. Das Modul wird durch die Präprozessor-Anweisung #include als Text eingebunden, daher nicht vorübersetzt und als Objektmodul zum Programm gebunden. Das Modul vom Typ MACRO enthält mit #define definierte Konstanten und Makros, sowie selbstdefinierte Datentypen, die global zu Verfügung gestellt werden aber keinem Programmmodul als Exportschnittstelle zugeordnet ist z.b. eine Konstante wie PI oder ein Makro NEWLINE. IMPLEMENTIERUNG Es existiert kein vorübersetzbarer C-Quelltext. SCHNITTSTELLE: Zu dem Modul existiert lediglich eine Headerdatei, in der mit der Präprozessor-Anweisung #define Konstanten oder Makros definiert und mit typedef selbstdefinierte Datentypen zu Verfügung gestellt werden.