Transcript Funktionen und Module Einführung anhand des Beispiels “Wörter sortieren” Timm Grams Fachhochschule Fulda Fachbereich Elektrotechnik und Informationstechnik © Timm Grams, Fulda, 23.05.01

Funktionen und Module
Einführung anhand des Beispiels “Wörter sortieren”
Timm Grams
Fachhochschule Fulda
Fachbereich Elektrotechnik und
Informationstechnik
© Timm Grams, Fulda, 23.05.01
Vorbemerkung - Übersetzungseinheiten
Ein C-Programm besteht im Allgemeinen aus
mehreren separat übersetzbaren Dateien:
Programm = translation-unit { translation-unit }
Demonstrationsbeispiel: Aufteilung eines Sortierprogramms auf separat übersetzbare Dateien.
Vorbemerkung - Definitionen und Deklarationen
Im Programm muss jede Variable und jede Funktion genau
einmal definiert werden.
Variablendefinitionen reservieren Speicherplatz.
Funktionsdefinitionen enthalten einen Funktionsblock (compound
statement).
In jeder separat übersetzbaren Datei muss jede verwendete
Variable oder Funktion definiert oder wenigstens deklariert
werden.
Variablendeklarationen: mit extern-Spezifikator.
Funktionsdeklarationen: ohne Block, mit extern-Spezifikator.
Deklarationen und Typ-Definitionen dürfen wiederholt auftreten.
Das Beispiel - Wörter sortieren
void main(){
char *x[100], buf[80];
int i, j, k, n;
char *a;
printf("Eingabe der Strings ...\n");
n=0;
do{
printf("? String = "); gets(buf);
x[n++]=strcpy(malloc(strlen(buf) + 1), buf);
} while(buf[0]);
--n;
for(i=1; i<n; i++) {
for (a=x[k=i], j=k--;
0<j && strcmp(a, x[k])<0; j=k--) x[j]=x[k];
x[j]=a;
}
printf("Ausgabe:\n");
for (i=0;i<n;i++) printf("! String = %s\n", x[i]);;
}
Sortierung generell nutzbar machen
Der Ausgangszustand
Das Programm besteht - abgesehen von Dateien der Standardbibliothek - aus einer Datei.
Es enthält Ein-/Ausgabe- und Verarbeitungsfunktionen.
Das Ziel
Sortieren ist als Funktion in einer separat übersetzbaren Datei
(translation unit) zu realisieren.
Die Sortierfunktion ist als obj-Datei generell verfügbar zu
machen.
Die Realisierung der Funktion soll geheim bleiben.
Die Größe des zu sortierenden Arrays darf nicht präjudiziert
werden.
Der Weg vom Ausgangszustand
zum Ziel
Aufteilen und Entflechten der Funktionen
Entkopplung der Dateien
Kontrollierte Parameterübergabe
Modulbildung mit klaren Schnittstellen und
Verantwortungsabgrenzung
Aufteilen und
Entflechten
char *x[100];
int n;
extern void sort();
void main(){
char buf[80];
int i;
printf("Eingabe ...
sort();
printf("Ausgabe:\n"); ...
}
void main(){
char *x[100], buf[80];
int i, j, k, n;
char *a;
printf("Eingabe ...
for(i=1; i<n; i++) ...
printf("Ausgabe:\n"); ...
}
void sort(){
extern char *x[];
extern int n;
int i, j, k;
char *a;
for(i=1; i<n; i++) ...
}
Entkopplung
und kontrollierte
Parameterübergabe
char *x[100];
int n;
extern void sort();
void main(){
char buf[80];
int i;
printf("Eingabe ...
sort();
printf("Ausgabe:\n"); ...
}
void main(){
char *x[100], buf[80];
int i, j, k, n;
char *a;
printf("Eingabe ...
for(i=1; i<n; i++) ...
printf("Ausgabe:\n"); ...
}
void sort(){
extern char *x[];
extern int n;
int i, j, k;
char *a;
for(i=1; i<n; i++) ...
}
Entkopplung
und kontrollierte
Parameterübergabe
void main(){
char *x[100], buf[80];
int i, j, k, n;
char *a;
printf("Eingabe ...
for(i=1; i<n; i++) ...
printf("Ausgabe:\n"); ...
}
extern void sort(char*[], int);
void sort(char *x[], int n){
void main(){
int i, j, k;
char *x[100], buf[80];
char *a;
int i, n;
for(i=1; i<n; i++) ...
printf("Eingabe ...
}
sort(x, n);
printf("Ausgabe:\n"); ...
}
Modulbildung
Verantwortungsabgrenzung
sortMain.c
#include “sortModule.h“
void main(){
char *x[100], buf[80];
int i, j, k, n;
char *a;
printf("Eingabe ...
for(i=1; i<n; i++) ...
printf("Ausgabe:\n"); ...
}
sortModule.h
extern void sort(char*[], int);
void main(){
sortModule.c
char *x[100], buf[80];
void sort(char *x[], int n){
int i, n;
int i, j, k;
printf("Eingabe ...
char *a;
sort(x, n);
for(i=1; i<n; i++) ...
printf("Ausgabe:\n"); ...
}
}
Die Header-Datei sortModule.h
/* sort(x, n) ueberfuehrt ein Array
von String-Elementen
x[0], x[1], ..., x[n-1] in die
lexikographische Ordnung.
***********************************/
extern void sort(char*[], int);
Inhalt von Header-Dateien
generell
Deklarationen der Funktionen und Variablen, die
exportiert werden sollen
Typ-Definitionen
Kommentare
Erläuterungen der Variablen und Datentypen
Beschreibung der Wirkung von Funktionen (Funktionsspezifikation mittels Vor- und Nachbedingungen)
Inhalt von Header-Dateien
im Einzelnen
Typ-Definitionen wie struct point {int x, y;}
Funktionsdeklarationen wie extern float f(float x);
Variablen-Deklarationen wie extern int a;
Konstantendefinitionen wie const float pi = 3.1415;
Include Direktiven wie #include "pow.h"
Kommentare wie /*Das ist ein Kommentar*/
Das modularisierte Programm
Kundenprogramm
sortMain.c
Lieferantenmodul
sortModule.h + sortModule.c
Gesamtprogramm
Kundenprogramm + Lieferantenmodul
Compiler-Aufrufe
compiler sortMain.c sortModule.c
compiler sortMain.c sortModule.obj
Gründe für die Modularisierung
Zerlegung großer Aufgaben in bewältigbare kleine
Arbeitsteilung: Aufteilung der Teilaufgaben auf verschiedene Arbeitsgänge
und Arbeitsgruppen. Verantwortungsabgrenzung
Programm-Strukturierung, beispielsweise nach dem EVA-Prinzip (Trennung
von Eingabe, Verarbeitung und Ausgabe)
Zeiteffizienz: Was fertig ist, muss nicht immer wieder neu übersetzt werden
Vorübersetzte Module sind Fertigprodukte, deren innerer Aufbau verborgen
bleibt (Information Hiding)
Entkopplung der Entwicklung steigert die Qualität der Software-Entwicklung
und verringert die Fehleranfälligkeit
Urheberrechtsschutz