Funktionen und Module Funktionen und Module

(1)

Funktionen und Module Funktionen und Module

Einführung anhand des Beispiels “Wörter sortieren”

Timm Grams Timm Grams

Fachhochschule Fulda Fachhochschule Fulda

Fachbereich Elektrotechnik und Fachbereich Elektrotechnik und

Informationstechnik Informationstechnik

(2)

Vorbemerkung

Vorbemerkung - Übersetzungseinheiten - Übersetzungseinheiten

Ein C-Programm besteht im Allgemeinen aus Ein C-Programm besteht im Allgemeinen aus mehreren separat übersetzbaren Dateien:

mehreren separat übersetzbaren Dateien:

Programm

Programm = = translation-unit translation-unit { { translation-unit translation-unit } } Demonstrationsbeispiel: Aufteilung eines Sortier- Demonstrationsbeispiel: Aufteilung eines Sortier- programms auf separat übersetzbare Dateien.

programms auf separat übersetzbare Dateien.

(3)

Vorbemerkung

Vorbemerkung - Definitionen und Deklarationen - Definitionen und Deklarationen Im Programm muss jede Variable und jede Funktion

Im Programm muss jede Variable und jede Funktion genau genau einmal definiert

einmal definiert werden. werden.

Variablendefinitionen reservieren Speicherplatz.

Funktionsdefinitionen enthalten einen Funktionsblock (compound Funktionsdefinitionen enthalten einen Funktionsblock (compound statement).

statement).

In jeder separat übersetzbaren Datei muss jede verwendete In jeder separat übersetzbaren Datei muss jede verwendete Variable oder Funktion

Variable oder Funktion definiert definiert oder wenigstens deklariert oder wenigstens deklariert werden.

werden.

Variablendeklarationen: mit

Variablendeklarationen: mit extern-Spezifikator.extern-Spezifikator.

Funktionsdeklarationen: ohne Block, mit

Funktionsdeklarationen: ohne Block, mit externextern-Spezifikator.-Spezifikator.

Deklarationen und Typ-Definitionen dürfen wiederholt auftreten.

(4)

Das Beispiel

Das Beispiel - Wörter sortieren - Wörter sortieren

void main(){

char *x[100], buf[80];char *x[100], buf[80];

int i, j, k, n; int i, j, k, n;

char *a; char *a;

printf("Eingabe der Strings ...\n"); printf("Eingabe der Strings ...\n");

n=0; n=0;

do{do{

printf("? String = "); gets(buf); printf("? String = "); gets(buf);

x[n++]=strcpy(malloc(strlen(buf) + 1), buf); x[n++]=strcpy(malloc(strlen(buf) + 1), buf);

} while(buf[0]); } while(buf[0]);

--n; --n;

for(i=1; i<n; i++) { for(i=1; i<n; i++) { for (a=x[k=i], j=k--; for (a=x[k=i], j=k--;

0<j && strcmp(a, x[k])<0; j=k--) x[j]=x[k];0<j && strcmp(a, x[k])<0; j=k--) x[j]=x[k];

x[j]=a; x[j]=a;

} }

printf("Ausgabe:\n"); printf("Ausgabe:\n");

for (i=0;i<n;i++) printf("! String = %s\n", x[i]);; for (i=0;i<n;i++) printf("! String = %s\n", x[i]);;

}}

(5)

Sortierung generell nutzbar machen Sortierung generell nutzbar machen

Der Ausgangszustand Der Ausgangszustand

Das Programm besteht - abgesehen von Dateien der Standard- Das Programm besteht - abgesehen von Dateien der Standard- bibliothek - aus einer Datei.

bibliothek - aus einer Datei.

Es enthält Ein-/Ausgabe- und Verarbeitungsfunktionen.

Das Ziel Das Ziel

Sortieren ist als Funktion in einer separat übersetzbaren Datei Sortieren ist als Funktion in einer separat übersetzbaren Datei (translation unit) zu realisieren.

(translation unit) zu realisieren.

Die Sortierfunktion ist als

objobj

-Datei generell verfügbar zu -Datei generell verfügbar zu machen.

machen.

Die Realisierung der Funktion soll geheim bleiben.

Die Größe des zu sortierenden Arrays darf nicht präjudiziert Die Größe des zu sortierenden Arrays darf nicht präjudiziert werden.

werden.

(6)

Der Weg vom Ausgangszustand Der Weg vom Ausgangszustand

zum Ziel zum Ziel

Aufteilen und Entflechten der Funktionen Aufteilen und Entflechten der Funktionen

Entkopplung der Dateien Entkopplung der Dateien

Kontrollierte Parameterübergabe Kontrollierte Parameterübergabe

Modulbildung mit klaren Schnittstellen und Modulbildung mit klaren Schnittstellen und

Verantwortungsabgrenzung

(7)

Aufteilen und Aufteilen und

Entflechten Entflechten

void main(){

printf("Eingabe ... printf("Eingabe ...

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

printf("Ausgabe:\n"); ...printf("Ausgabe:\n"); ...

}}

void sort(){

extern char *x[];extern char *x[];

extern int n; extern int n;

int i, j, k; int i, j, k;

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

}} char *x[100];

char *x[100];

int n;

extern void sort();

void main(){

char buf[80]; char buf[80];

int i;int i;

sort(); sort();

printf("Ausgabe:\n"); ... printf("Ausgabe:\n"); ...

}}

(8)

Entkopplung Entkopplung

und kontrollierte und kontrollierte

Parameterübergabe Parameterübergabe

void main(){

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

}}

void sort(){

extern char *x[];extern char *x[];

extern int n; extern int n;

int i, j, k; int i, j, k;

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

}} char *x[100];

char *x[100];

int n;

extern void sort();

void main(){

char buf[80]; char buf[80];

int i;int i;

sort(); sort();

}}

(9)

void main(){

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

}}

extern void sort(char*[], int);

void main(){

char *x[100], buf[80]; char *x[100], buf[80];

int i, n; int i, n;

sort(x, n);sort(x, n);

}}

void sort(char *x[], int n){

int i, j, k;int i, j, k;

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

}}

Entkopplung Entkopplung

und kontrollierte und kontrollierte

Parameterübergabe

(10)

#include “sortModule.h“

void main(){

char *x[100], buf[80]; char *x[100], buf[80];

int i, n; int i, n;

sort(x, n);sort(x, n);

}}

sortMain.c sortMain.c

Modul- Modul-

bildung bildung

Verantwortungs- Verantwortungs- abgrenzung

abgrenzung

void main(){

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

}}

extern void sort(char*[], int);

sortModule.h sortModule.h

void sort(char *x[], int n){

int i, j, k;int i, j, k;

for(i=1; i<n; i++) ... for(i=1; i<n; i++) ...

}}

sortModule.c sortModule.c

(11)

Die Header-Datei

Die Header-Datei sortModule.h sortModule.h

**/* sort(x, n) ueberfuehrt ein Array /* sort(x, n) ueberfuehrt ein Array von String-Elementen**

von String-Elementen

x[0], x[1], ..., x[n-1] in die x[0], x[1], ..., x[n-1] in die lexikographische Ordnung.

lexikographische Ordnung.

***********************************/

**extern void sort(char*[], int);**

(12)

Inhalt von Header-Dateien Inhalt von Header-Dateien

generell generell

Deklarationen der Funktionen und Variablen, die Deklarationen der Funktionen und Variablen, die exportiert werden sollen

exportiert werden sollen Typ-Definitionen

Typ-Definitionen Kommentare

Kommentare

Erläuterungen der Variablen und Datentypen Erläuterungen der Variablen und Datentypen

Beschreibung der Wirkung von Funktionen (Funktionsspezifi- Beschreibung der Wirkung von Funktionen (Funktionsspezifi- kation mittels Vor- und Nachbedingungen)

kation mittels Vor- und Nachbedingungen)

(13)

Inhalt von Header-Dateien Inhalt von Header-Dateien

im Einzelnen im Einzelnen

Typ-Definitionen wie

Typ-Definitionen wie struct point {int x, y;} struct point {int x, y;}

Funktionsdeklarationen wie

Funktionsdeklarationen wie extern float f(float x); extern float f(float x);

Variablen-Deklarationen wie

Variablen-Deklarationen wie extern int a; extern int a;

Konstantendefinitionen wie

Konstantendefinitionen wie const float pi = 3.1415; const float pi = 3.1415;

Include Direktiven wie

Include Direktiven wie #include "pow.h" #include "pow.h"

Kommentare wie

Kommentare wie **/Das ist ein Kommentar/ /Das ist ein Kommentar/**

(14)

Das modularisierte Programm Das modularisierte Programm

Kundenprogramm Kundenprogramm

sortMain.c sortMain.c

Lieferantenmodul Lieferantenmodul

sortModule.h + sortModule.c sortModule.h + sortModule.c

Gesamtprogramm Gesamtprogramm

Kundenprogramm + Lieferantenmodul Kundenprogramm + Lieferantenmodul

Compiler-Aufrufe Compiler-Aufrufe

compiler

compiler sortMain.c sortModule.c sortMain.c sortModule.c compiler

compiler sortMain.c sortModule.obj sortMain.c sortModule.obj

(15)

Gründe für die Modularisierung Gründe für die Modularisierung

Zerlegung großer Aufgaben

Zerlegung großer Aufgaben in bewältigbare kleine in bewältigbare kleine Arbeitsteilung:

Arbeitsteilung: Aufteilung der Teilaufgaben auf verschiedene Arbeitsgänge Aufteilung der Teilaufgaben auf verschiedene Arbeitsgänge und Arbeitsgruppen. Verantwortungsabgrenzung

und Arbeitsgruppen. Verantwortungsabgrenzung Programm-Strukturierung

Programm-Strukturierung, beispielsweise nach dem , beispielsweise nach dem EVA-Prinzip (Trennung EVA-Prinzip von Eingabe, Verarbeitung und Ausgabe)

Zeiteffizienz:

Zeiteffizienz: Was fertig ist, muss nicht immer wieder neu übersetzt werden Was fertig ist, muss nicht immer wieder neu übersetzt werden Vorübersetzte Module sind

Vorübersetzte Module sind Fertigprodukte,Fertigprodukte, deren innerer Aufbau verborgen deren innerer Aufbau verborgen bleibt (Information Hiding)

bleibt (Information Hiding) Entkopplung der Entwicklung

Entkopplung der Entwicklung steigert die Qualität der Software-Entwicklung steigert die Qualität der Software-Entwicklung und verringert die Fehleranfälligkeit

und verringert die Fehleranfälligkeit Urheberrechtsschutz

Urheberrechtsschutz