Die Verwendung von Unterprogrammen bringt sehr viele Vorteile mit sich. Sie sollten sich deren Verwendung unbedingt aneignen.
Wenn Ihnen die Grundlagen der Unterprogrammtechnik bekannt sind, erfahren Sie in diesem Artikel die Umsetzung der Unterprogrammtechnik in C / C++.
Funktionen ohne Übergabeparameter und Rückgabewerte
Die einfachste Art einer Funktion hat keine Übergabeparameter und keine Rückgabewerte. Ein Unterprogramm muss immer einen Namen bekommen, der möglichst aussagekräftig ist, also beschreibt, was die Funktion tut. Der Rückgabedatentyp wird vor den Funktionsnamen geschrieben. Gibt die Funktion keinen Wert zurück, wird als Datentyp void notiert. Die Übergabeparameter stehen in runden Klammern hinter dem Funktionsnamen. Bei einer Funktion ohne Parameter müssen die Klammern auch stehen, nur sind sie leer. Unsere Funktion sieht also folgendermaßen aus:
void meineErsteFunktion()
{
// Anweisungen.
}
Aufgerufen wird die Funktion, indem einfach ihr Name mit leeren runden Klammern notiert wird. meineErsteFunktion würde also folgendermaßen gestartet werden:
meineErsteFunktion();
Funktionen mit Übergabeparametern und ohne Rückgabewert
Übergabeparameter werden als lokale Variablen in den runden Klammern deklariert – also mit Variablennamen und Datentyp. Mehrere Parameter werden durch Kommas voneinander getrennt. Die Übergabeparameter sind lokale Variablen und somit nur innerhalb der Funktion gültig. Achten Sie darauf, dass die Übergabeparameter den verlangten Datentyp haben.
void meineZweiteFunktion(int wert1, int wert2)
{
// Anweisungen
}
Der Aufruf verläuft im Prinzip ähnlich, nur dass in den runden Klammern die Übergabeparameter stehen. Sie müssen also in der aufrufenden Funktion Variablen deklarieren, die Sie an die Funktion übergeben. Sie können natürlich auch konstante Werte übergeben. Im Folgenden sehen Sie einen Beispielaufruf der Funktion meineZweiteFunktion. Ihr werden eine Variable und eine Konstante übergeben.
int zahl1 = 9;
meineZweiteFunktion(zahl1, 6);
Funktionen ohne Übergabeparameter und mit Rückgabewert
Vor dem Funktionsnamen wird nur der Datentyp des Rückgabewerts angegeben. Welche lokale Variable zurückgegeben wird, wird mit Hilfe der Anweisung return bestimmt. Hinter return folgt der Name der zurückzugebenden Variable.
int meineDritteFunktion()
{
int variable;
// Weitere Anweisungen.
return variable;
}
Nun stellt sich die Frage: Wie gelangt die aufrufende Funktion an den Rückgabewert? Der zurückgegebene Wert muss in einer Variablen gespeichert werden. Im folgenden Codeschnipsel wird meineDritteFunktion aufgerufen und der Rückgabewert wird in der Variable myVariable gespeichert.
int myVariable = meineDritteFunktion();
Funktionen mit Übergabeparameter und mit Rückgabewert
Im Grunde erfahren Sie nun nichts Neues mehr. Sie müssen nur kombinieren, was Sie bisher gelernt haben. Die folgende Funktion erhält als Übergabeparameter zwei Variablen vom Typ int und gibt eine Variable vom Typ float zurück.
float meineVierteFunktion(int wert1, int wert2)
{
float variable;
// Weitere Anweisungen.
return variable;
}
Und in diesem Fall müssen Sie auch beim Aufruf nur das bereits Gelernte kombinieren. Sie rufen die Funktion auf, indem Sie ihr die Übergabeparameter übergeben und den Rückgabewert in einer Variablen speichern.
float ergebnis;
int zahl = 9;
ergebnis = meineVierteFunktion(zahl, 6);
Die Hauptfunktion – eine besondere Funktion
Als C/C++-Programmierer kennen Sie die Hauptfunktion. An dieser Stelle noch ein paar Worte zu diesem wichtigen Bestandteil eines Programms. Mit der Hauptfunktion oder Main-Funktion startet das Programm. Ihre erste Zeile ist die erste Programmzeile, mit ihrem Ende endet auch das Programm. Sie ist damit der Hauptbestandteil einer Software und muss genau einmal erscheinen. Rein technisch ist die Hauptfunktion eine Funktion wie alle anderen, nur dass sie automatisch gestartet wird. Sie können die Hauptfunktion nicht selbst aufrufen.
Sie kann void oder int zurückgeben. Einige Compiler erwarten, dass die Hauptfunktion int zurückgibt, was allgemein als guter Programmierstil gilt. Denn dadurch kann ein Fehlercode zurückgegeben werden, wenn das Programm nicht korrekt durchläuft. Übergabewerte werden keine benötigt.
Deklaration eines Unterprogramms
Unterprogramme müssen in C / C++ vor der ersten Benutzung deklariert werden. Bevor die Funktion aufgerufen werden kann, muss sie bekannt sein. Dazu gibt es zwei Möglichkeiten:
- Ausprogrammieren der Funktion vor dem ersten Aufruf.
- Deklarieren der Funktion.
Wenn Sie die Funktion vor dem ersten Aufruf ausprogrammieren möchten, müssen Sie genau auf die Reihenfolge achten: Der Code des Unterprogramms muss erfolgen, bevor es verwendet wird. Das kann bei sehr verschachtelten Aufrufen oder Programmveränderungen zu umfangreichen Anpassungen führen. Daher wird die zweite Variante empfohlen.
Deklaration einer Funktion ist im Prinzip ähnlich wie die Deklaration einer Variable. Die Funktion wird dem Programm bekannt gemacht. Dazu schreiben Sie nur den Funktionskopf, d.h. den Rückgabetyp, den Funktionsnamen und die Datentypen der Übergabeparameter. An dieser Stelle können Sie auch schon Namen für die Übergabeparameter notieren, das müssen Sie aber nicht und wird üblicherweise auch nicht getan. Abgeschlossen wird die Deklaration durch ein Semikolon. Wichtig ist, dass die Funktion an dieser Stelle keinerlei Programmcode enthält. Diesen bekommt sie erst später bei der Definition, die an beliebiger Stelle im Programm erfolgen kann.
Im Folgenden sehen Sie die Deklarationen der in diesem Artikel beschriebenen Beispielfunktionen.
void meineErsteFunktion();
void meineZweiteFunktion(int, int);
intmeineDritteFunktion();
float meineVierteFunktion(int, int);
Wenn Sie die Funktionen am Anfang des Programms vor der Hauptfunktion deklarieren, müssen Sie bei der Implementierung der Funktionen nicht auf die Reihenfolge achten.
Beispiel
#include
#include
#include
// Deklarationen der Funktionen.
int quadriere(int);
int summiere(int, int);
// Die Hauptfunktion.
int main()
{
int zahl = 4;
// Aufrufen der Funktion quadriere(). Der Rückgabewert wird in ergebnis gespeichert.
int ergebnis = quadriere(zahl);
cout << „Ergebnis von quadriere(): “ << ergebnis << endl;
// Aufruf der Funktion summiere().
ergebnis = summiere(zahl, 6);
cout << „Ergebnis von summiere(): “ << ergebnis << endl;
getch();
}
// Implementierung der Funktion quadriere().
int quadriere(int zahl)
{
return zahl * zahl;
}
// Implementierung der Funktion summiere().
int summiere(int zahl1, int zahl2)
{
return zahl1 + zahl2;
}