Willkommen beim vierten Teil des C-Kurses!
Module

Nachdem wir nun schon etwas hineingeschnüffelt haben, wie C-Programme aufgebaut sind, machen wr uns nun daran eigene Unterprogramme zu programmieren.
Wie schon früher erwähnt wurde ist C modular aufgebaut, d.h. das die meisten Befehle Unterprogramme sind, die sich aus einfacheren aufbauen. Der printf-Befehl ist z.B. ein solches Modul. Das bringt uns natürlich auf die Idee eigene Befehle, also Module zu schreiben.
 

/* Beispiel fue Modulprogrammierung */ 
#include <stdio.h>

 
/* Prototypen der Module */

 
void hallo (void); 
int frage (int);
void antwort (int, float);

 
/* Hauptprogramm */
void main (void)
{
    int b=2, c;
    float zahl=1.34;

     
    hallo ();
    c = frage (b);
    antwort (c, zahl);
}

 
/* Module */
void hallo (void) 
{
    printf ("\n\nDas Modul sagt HALLO :-)\n\n");
}

 
int frage (int eingabe)
{
    int rueckgabe;

     
    printf ("\nEs wurde der Wert %d uebergeben",eingabe);
    printf ("\nBitte einen Integerwert, z.B. 2 : ");
    scanf ("%d",&rueckgabe);

     
    return rueckgabe; 
}

 
void antwort (int zahl1, float zahl2) 
{
    printf ("\n\nModul 'antwort' meldet sich");
    printf ("\nEs wurden %d und %f übergeben\n\n",zahl1,zahl2);
}

 
 
 
Prototypen 

Bevor der C-Compiler unsere neuen Module benutzen kann, muß er wissen, welche Art von Datentypen von Modul wir benutzen wollen. Dazu schreiben wir sogenannte Prototypen. Das sind Modulköpfe, die nur den Rückgabetyp und den Parametertyp eines Moduls enthalten.
 

Rückgabetyp Modulname ( Parametertyp(en) );

Der Rückgabetyp bezeichnet den Variablentyp der Variablen, die das Programm zurückgibt. Der Modulname ist der Name unseres Unterprogrammes. Der Parametertyp gibt an, welche Variablentypen ich an das Programm übergebe. Es können mehrere Parametertypen übergeben werden, die werden dann mittels eines Kommas voneinander getrennt.
 

void hallo (void); 

int frage (int);

In unserem Beispiel wird ein Integerwert an das Programm übergeben und ein Integerwert zurückgegeben.

Aufgerufen wird das Programm mit:
 

int b,c;

c = frage ( b );

Der Rückgabewert wird in 'c' gespeichert. Zu beachten ist, das die Variablentypen vom Rückgabewert und der Variable gleich sein müssen, in der der Rückgabewert gespeichert wird.

Was, wenn wir nun keine Werte übergeben wollen und keine zurückkriegen ? Dafür wurde 'void' eingeführt. Damit wird dem Compiler gesagt: Hier wird kein Variablentyp übergeben oder zurückgegeben.

Der Aufruf gestaltet sich in unserem Beispiel daher recht einfach:
 
 

hallo ( );

Da das Modul nichts zurückgibt, benötigt man nur den Modulnamen ohne Parameter. Das einzige, was noch stehen bleiben muß, sind die leeren runden Klammern, da ja 'nichts' übergeben wird.
 
 
Aufbau von Modulen anhand der Prototypen

Die Module sind wie folgt aufgebaut:
 
 

Rückgabetyp Modulname ( Parametertyp(en) )
{ 
    /* Modulkörper */
}

 

Mit den Parametern wird hier gleich eine Variablendeklaration durchgeführt.
 
 

/* Prototyp */ 
int test ( int );

 
:
:

 
/* Modul */
int test ( int a ) 
{
    /* Modulkörper */
    return Rueckgabe;
}

Den erzeugten Variablen wird der Wert des Übergabeparameters zugewiesen.
Wird das Modul mit
 
 
 

c = test ( 3 );

aufgerufen, so wird im Modul der Variable 'a' der Wert 3 zugewiesen.
Innerhalb eines Moduls wird ein Rückgabewert mittels
 
 
 

return Rückgabewert im Format des Rückgabetypen;

Steht nun ein VOID als Rückgabetype braucht natürlich kein 'return' stehen.

Das ganze funktioniert natürlich auch mit Zeigern. Zu beachten bei den Prototypen ist:

Wird ein Zeiger als Rückgabewert benutzt, so wird im Prototyp und im Modulkopf der Stern hinter dem Rückgabewert gesetzt.

Bsp.:
 

char* Modulname (void) ...

Mit dem Wissen aus dem letzten Kursteil, der die Zeiger betraf, müßten sie es schaffen das folgende Programm zu verstehen:
 
 

/* Beispiel fuer Modulprogrammierung 2 */ 
#include <stdio.h>
 

/* Prototypen */
char* zeichen (void);
 

 /* Hauptprogramm */
void main (void) 
{

printf ("\n\nSie gaben ein : %s\n\n",zeichen()); 
 }
 

char* zeichen (void)
{

char string[200];
char *rueck;
 

printf ("\n\nBitte ein Wort eingeben : ");
scanf ("%s",&string);
printf(" - %s ",string);

/*
rueck zeigt auf das erste Zeichen
von string
*/

 rueck = string;
 

return rueck;

}

Damit steht auch unsere kleine Hausaufgabe :-)

Wenn Fragen bestehen sollten, oder Verständnisschwierigkeiten da sind kann man mir entweder eine Mail schreiben, oder eine Nachricht im Programmierforum => Pinboard/C-Kurs oder C-Kurs-Talk schreiben.
 
 
 
 
...das Obligatorische

Autor: Sebastian Cyris \ PCD Bascht

Dieser C-Kurs dient nur zu Lehrzwecken! Eine Vervielfältigung ist ohne vorherige Absprache mit dem Autor verboten! Die verwendete Software unterliegt der GPL und unterliegt der Software beiliegenden Bestimmungen zu deren Nutzung! Jede weitere Lizenzbestimmung die der benutzten Software beiliegt, ist zu beachten!