ein Kapitel zurück                                           ein Kapitel weiter

Sie hatten jetzt in dem vorletzten Kapitel einen kurzen Einblick zum Thema Funktionen bekommen. Jetzt wollen wir dieses Thema vertiefen.

Wollen wir uns mal ansehen wie die Ausführung einer Funktion in einem Programmablaufplan aussieht...

Funktionsaufruf PAP


Sie können sich dies etwa so vorstellen. Durch den Funktionsaufruf wird zuerst zur ersten Anweisung der Funktion gesprungen. Hinter der letzten Anweisung in der Funktion kann man sich eine Rücksprungbefehl hinzudenken. Mit diesem Rücksprungbefehl wird unmittelbar hinter dem Funktionsaufruf zurückgesprungen. Das ganze anhand eines Quellcodes bildlich....

Funktionen


1. Funktion mit Wertübergabe
Als erstes möchte ich Ihnen zeigen wie man an Funktionen einen Wert übergibt und die Funktion den Wert dann weiterverwendet. Zuerst wieder mal ein Programmbeispiel...

/*Download:func8.c*/
#include <stdio.h>

/*Berrechnung von Quadratflächen*/

void quadrat(int zahl)
{
printf("Die Quadratfläche ist %d\n",zahl*zahl);
}

int main()
{
int x;
printf("Bitte geben sie ein Zahl ein : ");
scanf("%d",&x);

quadrat(x); /*Gibt Wert x an die Funktion quadrat*/

return 0;
}

Das Programm fordert sie auf eine Zahl einzugeben. Nehmen wir an sie haben die Zahl 5 eingegeben. Somit ist der Wert von int x =5. Als nächstes steht da....

quadrat(x);

Damit wird die Funktion quadrat() aufgerufen. In den Klammern des Funktionsaufrufes steht unsere Variable x die der Funktion gleich als Wert mitgegeben wird. Unser Funktionskopf sieht ja folgendermaßen aus...

void quadrat(int zahl)

Das heißt jetzt unsere Funktion ist vom Typ void und verlangt somit keinen Rückgabewert (void="leer"). In den Klammern der Funktion steht die Variable 'int zahl' . Das ist der Wert, den wir an unsere Funktion durch den Aufruf 'quadrat(x)', übergeben haben. Somit ist der Wert von 'int zahl' jetzt 5. Diesen Wert nennt man Funktionsparameter und sie sind die lokalen Variablen der Funktion. Jetzt sind wir in der Lage, in unserer Funktion mit dem Wert 5 zu arbeiten. Und diese Zahl benutzen wir in unserer Funktion um das Quadrat der Zahl zu errechnen und auszugeben. Würden sie die Funktion Aufrufen ohne einen Wert (Parameter) zu übergeben so würde sich der Compiler mit einer Fehlermeldung beschweren. Das ganze Prinzip nennt man CALL-BY-VALUE. Die heißt das beim Aufruf der Funktion die aktuellen Parameter, die sie der Funktion übergeben, in lokale Speicherstellen der Funktion kopiert werden. Dies ist nötig, damit man anschließend innerhalb der Funktion, auf diese Variable(n) zugreifen kann, als wären sie in der Funktion deklariert worden. Das bedeutet auch das, in unserem Beipiel, eine Veränderung der Variable in der Funktion keine Veränderung für die Variable in der main()-Funktion hat. Beide haben eine andere Adresse im Speicher.

2. Funktionen mit Wertrückgabe
Wir habe jetzt eine Funktion kennen gelernt der wir eine Wert übergeben haben, nun werden wir die Methode kennen lernen bei der uns die Funktion wieder einen Wert zurückgibt. Ich habe es im Kapitel -int main oder void main- kurz angeschnitten. Nämlich den Befehl 'return'. Benutzen wir doch gleich dazu unser 'Quadratberechnungsprogramm' von oben...

/*Download:func9.c*/
#include <stdio.h>

/*Berrechnung von Quadratflächen*/

int quadrat(int zahl)
{
return (zahl*zahl);
}

int main()
{
int x;
printf("Bitte geben sie ein Zahl ein : ");
scanf("%d",&x);

printf("Das Quadrat ist %d\n",quadrat(x));

return 0;
}

Wie sie sehen hat sich nicht allzu viel an unserem Programm geändert. Der Ablauf ist wie gehabt. Sie geben wieder eine Zahl ein, der Funktionsaufruf mit Parameterübergabe erfolgt dies mal mit...

printf("Das Quadrat ist %d\n",quadrat(x));

Wir haben den Funktionsaufruf gleich mit in die printf - Ausgabe verpackt, da wir von unserer Funktion ja einen Integerwert zurück erwarten. Genausogut hätten wir eine neue Variable in der main()-Funktion definiert können um dieser anschließend den Rückgabewert zu übergeben. Das die Funktionen einen Wert zurückliefert, erkennen sie daran das unsere Funktion jetzt mit 'int' beginnt.....

Das heißt jetzt das diese Funktion eine Rückgabewert erwartet vom Typ 'int' . Und denn bekommt sie mit dem Aufruf....

return (zahl*zahl);

Unsere Funktion gibt nun an die main() - Funktion den Wert zahl*zahl zurück. Was die Ausgabe unserer main() - Funktion bestätigt. Hier eine andere Möglichkeit unseres Programms, mit dem selben Effekt...

/*Download:func10.c*/
#include <stdio.h>

/*Berrechnung von Quadratflächen*/

int quadrat(int zahl)
{
int request;
request = zahl*zahl;
return zahl;
}

int main()
{
int x;
int ergebnis;
printf("Bitte geben sie ein Zahl ein : ");
scanf("%d",&x);

ergebnis=quadrat(x);
printf("Das Quadrat ist %d\n",ergebnis);

return 0;
}

Ein weiteres Beispiel......

/*Download:func11.c*/
#include <stdio.h>

/*Ist das Drehteil zu klein dann Rückgabewert 1 ansonsten 0*/

int untermass(int mass)
{
return((mass<15) ? 1 : 0);
}

/*Ist das Drehteil zu gross gibt die Funktion 1 zurück ansonsten 0*/
int uebermass(int mass)
{
return((mass>20) ? 1 : 0);
}

/*Funktion gibt die Geschwindigkeitseinstellung der Maschine zurück*/

void akkord(int stueckzahl)
{
if(stueckzahl<100)
printf("Maschine schneller stellen\n");

else if(stueckzahl>100 && stueckzahl<120)
printf("Maschine läuft optimal\n");

else
printf("Maschine läuft zu schnell!!!\n");
}


int main()
{
int m,st;
printf("Bitte den Durchmesser des Drehteiles : ");
scanf("%d",&m);
printf("Bitte Stückzahl dieser Stunde eingeben: ");
scanf("%d",&st);

if(untermass(m))
printf("Drehteil AUSSCHUSS!!!\n");
else if(uebermass(m))
printf("Drehteil nachbearbeiten\n");
else
printf("Drehteil OK freigegeben\n");

akkord(st);

return 0;
}

In diesem Beispiel kommt noch einmal so ziemlich alles erlernte aus den Vorherigen Kapiteln vor. Hier wird überprüft ob Drehteile im richtigen Mass sind und ob genügend Stückzahl gemacht wird. Natürlich sollte das Programm automatisch ablaufen aber dazu fehlt uns es noch was an Wissen. An diesem Programm könnte man z.B. noch vieles hinzufügen und verbessern. Wie z.B...

if((stueckzahl

usw. Sie sehen wie einfach es ist aus den paar Sachen die wir kennen gelernt haben ein Programm zu machen.

Nun werden ein paar von euch schon Rätseln wie man das Beispiel das ich eben erwähnte Einfügen kann. Dazu fehlt uns nach ein weiterer Baustein unseres Wissens...

3. Übergabe mehrerer Parameter an die Funktion
Dies funktioniert eigentlich auch nicht anderes wie mit einem Parameter aber ... schauen sie einfach selbst ...

/*Download:func12.c*/
#include <stdio.h>

int max(int z1, int z2)
{
int maximus;

if(z1>z2)
maximus=z1;
else
maximus=z2;

return maximus;
}


int main()
{
int a,b;
printf("Zahl 1 : ");
scanf("%d",&a);
printf("Zahl 2 : ");
scanf("%d",&b);

printf("Die größte Zahl ist %d\n",max(a,b));

return 0;
}

Der Funktionsaufruf erfolgt mittels...

printf("Die größte Zahl ist %d\n",max(a,b));

Übergeben wir die zuvor beiden eingegebenen Zahlen an die Funktion max() . Wobei der Parameter 'a' an 'z1' und 'b' an 'z2' übergeben wird. In unserer Funktion wird dann überprüft welche unserer beiden Zahlen die größere ist. Dieser wird dann an unsere in der Funktion definierte Variable 'int maximus' übergeben und der Wert von int maximus ist dann gleichzeitig auch unser Rückgabewert an die main() - Funktion. Wie sie auch sehen müssen sie den Rückgabewert nicht unbedingt in Klammern setzten. Natürlich ginge unsere Funktion auch kürzer...

int max(int z1, int z2)
{
    return((z1
}


Jetzt können wir unser Programm von oben um die Funktion mit 2 Parametern erweitern...

/*Download:func13.c*/
#include <stdio.h>

/*Funktion wird von der Funktion untermass() aufgerufen und gibt einen Möglichen Fehler des Ausschusses der Drehteile aus*/

void ausschuss(int stueckzahl)
{
if(stueckzahl>120)
printf("\nMöglicher Fehler : Maschine zu schnell!!\n\n");

return;
}

/*Ist das Drehteil zu klein dann Rückgabewert 1 und ruft die Funktion ausschuss() auf ansonsten Rückgabe 0*/

int untermass(int mass,int stueckzahl)
{
if(mass<15)
{
ausschuss(stueckzahl);
return 1;
}

else
return 0;
}

/*Funktion gibt die Geschwindigkeitseinstellung der Maschine zurück*/

void akkord(int stueckzahl)
{
if(stueckzahl<100)
printf("Maschine schneller stellen\n");

else if(stueckzahl>100 && stueckzahl<120)
printf("Maschine läuft optimal\n");

else
printf("Maschine läuft zu schnell!!!\n");
}


int main()
{
int m,st;
printf("Bitte den Durchmesser des Drehteiles : ");
scanf("%d",&m);
printf("Bitte Stückzahl dieser Stunde eingeben: ");
scanf("%d",&st);

if(untermass(m,st))
printf("Drehteil AUSSCHUSS!!!\n");
else if(uebermass(m))
printf("Drehteil nachbearbeiten\n");
else
printf("Drehteil OK freigegeben\n");

akkord(st);

return 0;
}

Wir geben wieder den Durchmesser unseres Drehteiles und die Stückzahlen der Stunde ein. Dann folgt unser erster Funktionsaufruf mit....

if(untermass(m,st))

Dies ruft unsere Funktion untermass() auf und übergibt die beiden Variablen 'm' und 'st' and die beiden Parameter der Funktion......

int untermass(int mass,int stueckzahl)
{
   if(mass<15)
     {
       ausschuss(stueckzahl);
       return 1;
     }

   else
     return 0;
}


Wenn unser Werkzeug kleiner wie 15 ist wird die Funktion ausschuss(stueckzahl) aufgerufen der wir unseren Parameter int stueckzahl übergeben. Bei der Funktion ausschuss(stueckzahl) wird überprüft wie viele Drehteile in der Stunde gefertigt wurden. An dieser Funktion können sie auch schön sehen das es auch möglich ist in Funktionen weitere Funktionen aufzurufen. Wenn mehr wie 120 Stück gemacht wurden gibt die Funktion aus, das wahrscheinlich zu schnell gearbeitet wird (Quantität statt Qualität). Wenn nicht gibt die Funktion gar nichts aus und springt wieder zurück zu unserer Funktion untermass() zurück. Der Ausdruck...

return;

in unserer Funktion ausschuss kann auch weggelassen werden. Zurück in unserer Funktion geht es nach unserem Funktionsaufruf untermass() weiter und das wäre...

return 1;

Das heißt jetzt unsere Funktion untermass() vom Typ int gibt den Wert 1 an die main() - Funktion zurück. Oder genauer an 'if(untermass(m,st))' . Somit sollte die Funktion untermass 1 zurückgeben wäre die Bedienung in unserer if - Anweisung richtig und würde somit ausgeben das das Werkteil AUSSCHUSS ist. Falls aber unserer Funktion untermass() 0 zurückgeben würde das heißen die Bedienung der if - Abfrage ist 0(falsch), somit ist unser Werkteil nicht zu klein und kein Ausschuss. Daher überprüfen wir das Werkzeug dann ob es noch eine zu großen Durchmesser hat mit dem Funktionsaufruf.....

else if(uebermass(m))

wir übergeben der Funktion den Parameter m. Unser Funktion...

int uebermass(int mass)
{
    return((mass
}


...testet jetzt ob das Werkteil noch zu groß ist. Ich habe hier den Bedienungsoperator eingesetzt anstatt einer if-else - Anweisung. Den habe ich gleich in Klammern in dem return-Befehl verpackt. Zur Erinnerung: Wir prüfen ob das Maß größer wie 20 ist (mass1 an main() zurückgeben hat unser Werkzeug Übermaß und es wird ausgegeben das es nachbearbeitet werden muss. Falls aber unsere Funktion uebermass 0 zurückgibt geht's zu.....

else
   printf("Drehteil OK freigegeben\n");


...und unser Werkzeug ist OK. Jetzt wird nur noch die Funktion...

akkord(st);

...aufgerufen mit dem Parameter unserer Stückzahl die wir eingegeben haben um zu checken ob die Stückzahl dieser Stunde auch ausreichend ist. Den Ablauf dieses Aufrufes können sie zur Übung mal selber nachvollziehen.

Ein kleiner Tipp vielleicht um besser zu verstehen wie unser Programm abläuft, benutzen sie einen Debugger. Damit haben sie die Möglichkeit das Programm Schritt für Schritt durchzugehen.

Jetzt haben sie die Grundlagen über Funktionen gelernt. Eigentlich fehlt uns da noch die Rekursion. Das sind Funktionen die sich selbst Aufrufen. Aber dies bedarf etwas mehr an Erklärung und bekommt somit ein eigenes Kapitel.

ein Kapitel zurück          nach oben           ein Kapitel weiter


© 2001,2002 Jürgen Wolf