Der wichtigste Grund für die Verwendund von Funktionen liegt in der Unterstützung des grundlegenden Programmaufbaues. Die Aufteilung eines Programms in Funktionen ist, eines der Hauptprinzipien der stukturierten Programmierung.
Ein anderer Grund für dir Verwendung von Funktionen (und der Grung, warum sie vor langer Zeit erfunden worden sind) liegt darin, daß man durch sie die Größe des Programms vermindern kann. Jede Aufeinanderfolge von Befehlen, die mehr als einmal in einem Programm auftaucht, ist dafür prädestiniert, in einer Funktion zusammengefaßt zu werden. Der Kode der Funktion wird wird nur an einem Platz im Speicher aufbewahrt, selbst wenn diese Funktion während des Programmablaufs mehrmals ausgeführt wird.
Funktionen erfüllen in C++ (und C) denselben Zweck wie Unterprogramme und Prozeduren in Basic bzw. Prozeduren und Funktionen in Pascal.
Unser erstes Beispiel veranschaulicht eine einfache Funktion, deren Aufgabe darin besteht, eine Zeile
mit 45 Sternchen zu drucken. Das Beispielprogramm erzeugt einen Tabele, und die Zeilen mit den Sternchen
werden verwendet, um die Tabelle übersichtlicher zu gestalten.
Hier ist das Programmlisting von TABLE:
Die Ausgabe des Programms sieht folgendermaßen aus:// table.cpp // Veranschaulicht einfache Funktionen #include <iostream.h> void starline(); // Funktionsdeklaration (Prototyp) void main() { starline(); // Aufruf der Funktion cout << "Datentyp Wertbereich" << endl; starline(); // Aufruf der Funktion cout << "Char -128 bis 127" << endl; cout << "int -32768 bis 32767" << endl; cout << "double -2147483648 bis 2147483647" << endl; starline(); } // starline() // Funktionsdefinition void starline() // Funktionsdeklaration { for(int j=0; j<45; j++) // Funktionskörber cout << '*'; cout << endl; }
Das Programm besteht aus zwei Funktionen: main() und starline(). Sie haben bereits viele Programme kennengelernt, die nur main() verwenden. Welche anderen Komponenten sin notwendig, um den Programm eine Funktion hinzuzufügen? Es sind drei: Die Funktionsdeklaration, die Funktionsaufrufe und die Funktionsdefinition.******************************************************* Datentyp Wertebereich ******************************************************* char -128 bis 127 int -32768 bis 32767 double -2147483648 bis 2147483647 *******************************************************
Wir könnten beispielweise TABLE zu TABLE2 umschreiben, in welchem die Funktionsdefinition zuerst erscheint:
// table2.cpp // Veranschaulicht den Fall, daß die Funktionsdefinition den // Funktionsaufrufen vorausgeht #include <iostream.h> // Keine Funktionsdeklaration // starline // Funktionsdefinition void starline() { for(int j=0; j<45; j++) // Funktionskörber cout << '*'; cout << endl; } void main() { starline(); // Aufruf der Funktion cout << "Datentyp Wertbereich" << endl; starline(); // Aufruf der Funktion cout << "Char -128 bis 127" << endl; cout << "int -32768 bis 32767" << endl; cout << "double -2147483648 bis 2147483647" << endl; starline(); }
Lassen Sie uns zum Beispiel annehmen, daß die im letzten Beispiel verwendete Funktionen starline() für unsere Ansprüche zu unflexibel ist. An Stelle einer Funktion, die immer nur 45 Sternchen pro Reiche druckt, wollen wir eine Funktion, die jedes gewünschte Zeichen beliebig oft druckt.
Hier ist ein Programm mit dem Namen TABLEARG, das eine sollche Funktion enthält. Wir verwenden Argumente, um das von uns gewünschte zu druckende Zeichen und die anzahl der zu druckenden Zeichen zübergeben.
Es folgt die Ausgabe von TABLEARG:// tablearg.cpp // Veranschaulicht Funktionsargumente #include <iostream.h> void repchar(char, int); // Funktionsdeklaration void main() { repchar('-',43); // Aufruf der Funktion cout << "Datentyp Wertbereich" << endl; repchar('=',23); // Aufruf der Funktion cout << "Char -128 bis 127" << endl << "int -32768 bis 32767" << endl << "double -2147483648 bis 2147483647" << endl; repchar('-',43); // Aufruf der Funktion } // repchar() // Funktionsdefinition void repchar(char ch, int n) // Funktionsdeklaration { for(int j=0; j<n; j++) // Funktionskörber cout<< ch; cout << endl; }
----------------------------------------------------- Datentyp Wertebereich ======================= char -128 bis 127 int -32768 bis 32767 double -2147483648 bis 2147483647 -----------------------------------------------------
Ganze Strukturen können als Argumente an Funktionen übergeben werden. Das nächste Beispiel weist eine Funktion auf, die ein Argument vom Typ Distance verwendet. Hier ist das Programmlisting von ENGLDISP:
Es folgt ein Beispieldialog mit dem Programm:// engldisp.cpp // Veranschaulicht die Übergabe von Strukturen als Argument #include <iostream.h> struct Distance // Englische Längeneinheit { int feet; float inches; }; void engldisp(Distance); // Deklaration void main() { Distance d1,d2; // Zwei Längen definieren // Einlesen der vom Anwender einzugebenden Länfge d1 cout << "\nGeben Sie Feet ein:"; cin >> d1.feet; cout << "Geben Sie Inch ein:"; cin >>; d1.inches; // Einlesen der vom Anwender einzugebenden Länfge d2 cout << "\nGeben Sie Feet ein:"; cin >> d2.feet; cout << "Geben Sie Inch ein:"; cin >> d2.inches; cout << "\nd1 = "; engldisp(d1); // Länge 1 anzeigen cout << "\nd2 = "; engldisp(d2); // Länge 2 anzeigen } // angldisp() // Anzeige der Struktur vom Typ Distance in Feet und Inch void engldisp(Distance dd) // Parameter dd vom Typ Distance { cout << dd.feet << "\'-" << dd.inches << "\""; }
Geben Sie Feet ein: 6
Geben Sie Inch ein: 4
Geben Sie Feet ein: 5
Geben Sie Inch ein: 4.25
d1 = 6'-4"
d2 = 5'-4.25"
Wenn die ausführung einer Funktion abgeschlossen wird, kann sie einen
einzelnen Wert an das aufrufende Programm zurückgeben. Gewöhnlich besteht dieser Rückgabewert in einer Antwort
auf das Problem, das die Funktion gelöst hat. Das nächste Beispiel veranschaulicht eine Funktion, die ein
Gewicht in Kilogramm zurückgibt, nachdem man ein Gewicht in Pound (1 lb = 0,453592 kg) eingegeben hat.
Hier folgt das Listing das Programms CONVERT:
Es folgt ein Dialog mit diesem Programm:// convert.cpp // Veranschaulicht Rückgabewerte, wandelt Pound in kg um #include <iostream.h> float lbstokg(float); void main() { float lbs, kgs; cout << "\nGeben Sie Ihr Gewicht in Pound ein: "; cin << lbs; kgs = lbstokg(lbs); cout << "Ihr Gewicht in kg ist " << kgs; } // lbstokg() // Wandelt Pound in Kilogramm um float lbstokg(float pounds) { float kilograms = 0.453592 * pounds; return kilograms; }
Geben Sie Ihr Gewicht in Pounds ein: 182
Ihr Gewicht in kg ist 82.553741
Wir haben gesehen, daß Struckturen von Funktionen verwendet werden können. Sie können Struckturen ebenfalls als Rückgabewerte einsetzen. Hier folgt das Programm RETSTRC, das eine Funktion einschließt, die Variablen vom Typ Distance miteinander addiert und einen Wert desselben Typs zurückgibt:
Das Programm fordert den Anwender zur Eingabe zweier Längenangaben in der Maßeinheit Feet und Inch auf, addiert diese durch den Aufruf der Funktion addEngl() und zeigt das Ergebnis unter Anwendung der im Programm ENGLDISP eingeführten Funktion engldisp() an. Hier ist ein Dialog mit dem Programm:// retstrc.cpp // Veranschaulicht die Rückgabe einer Strucktur #include <iostream.h> struct Distance // Englische Längeneinheit { int feet; float inches; }; Distance addengl(Distance,Distance); // Deklaration void engldisp(Distance); void main() { Distance d1,d2,d3; // Drei Längen definieren // Einlesen der vom Anwender einzugebenden Länge d1 cout << "\nGeben Sie Feet ein: "; cin >> d1.feet; cout << "Geben Sie Inch ein: "; cin >> d1.inches; // Einlesen der vom Anwender einzugebenden Länge d2 cout << "\nGeben Sie Feet ein: "; cin >> d2.feet; cout << "Geben Sie Inch ein: "; cin >> d2.inches; d3 = addengl(d1,d2); // d3 ist die Summe von d1 und d2 engldisp(d1); cout << " + "; // Alle Längen anzeigen engldisp(d2); cout << " = "; engldisp(d3); cout << "\n"; } // addengl() // Addiert zwei Struckturen vom Typ Distance, gibt Summe zurück Distance addengl(Distance dd1,Distance dd2) { Distance dd3; // Definiert eine neue Struktur für die Summe dd3.inches = dd1.inches + dd2.inches; // Addiert Inch dd3.feet = 0; // (für möglichen Übertrag) if(dd3.inches >= 12.0) // Wenn Inch >= 12.0 sind dann Inch vermindern { dd3.inches -= 12.0; dd3.feet++; } dd3.feet += dd1.feet + dd2.feet; // Addiert Feet return dd3; // gibt Struktur zurück } // engldisp() // Anzeige der Struktur vom Typ Distance in Feet und Inch void engldisp(Distance dd) { cout << dd.feet << "\'-" << dd.inches << "\""; }
Geben Sie Feet ein: 4
Geben Sie Inch ein: 5.5
Geben Sie Feet ein: 5
Geben Sie Inch ein: 6.5
4'-5.5" + 5'-6.5" = 10'-0"
Dieses Programm druckt drei Zeilen mit Zeichen aus. Hier ist die Ausgabe:// overload.cpp // Veranschaulicht Funktionsüberlagerung #include <iostream.h> void repchar(); void repchar(char); void repchar(chr,int); void main() { repchar(); repchar('='); repchar('+',30); } // repchar() // Gibt 45 Sternchen auf den Bildschirm aus void repchar() { for int j=0;j<45;j++) cout << '*'; cout << endl; } // repchar() // Gibt 45 Kopien eines festgelegten Zeichen auf den Bildschirm aus void repchar(char ch) { for int j=0;j<45;j++) cout << ch; cout << endl; } //repchar // Gibt festgelegte Anzahl eines festgelegten Zeichen auf dem Bildschirm aus void repchar(char ch,int n) { for int j=0;j<n;j++) cout << '*'; cout << endl; } void repchar(chat
*********************************************<br>============================================= ++++++++++++++++++++++++++++++
Überraschenderweise kann man eine Funktion aufrufen, ohne alle ihre Argumente festgelegt zu haben. Dies wird aber nicht bei jeder Funktion Funktion funktionieren: Die Funktionsdeklaration muß Standardwerte für die nicht festgelegten Argumenten bereitstellen.
Hier folgt ein Beispiel, das eine Variante OVERLOAD ist und die Wirkunksweise von Standardargumenten veranschaulicht. In OVERLOAD haben wir drei verschiedene Funktionen mit demselben Namen verwendet, um verschiedene Anzahlen von Argumenten zu handhaben. Das vorliegende Beispiel MISSARG erreicht dieselbe Wirkung auf einem anderen Weg.
// missarg.cpp // Veranschaulicht vom Anwender nicht festgelegte Argumente und Standardargumente #include <iostream.h> void repchar(char='*',int=45); // Prototyp mit Standardargumenten void main() { repchar(); repchar('='); repchar('+',30); } // repchar() // Gibt eine Zeile mit Zeichen auf den Bildschirm aus void repchar(char ch,int n) { for (int j=0;j<n;j++) cout << ch; cout << endl; }
Die nächste wichtige Speicherglasse heißt extern. Extrerne Variablen werden auch als globale Variablen bezeichent, da sie von allen Funktionen des Programms erkannt werden.
Es folgt das Programm namens EXTREN, in dem alle drei Funktionen auf externe Variablen zugreifen.
// extern.cpp // Veranschaulicht externe Variablen #include <iostream.h> #include <conio.h> // Für grtch() char ch = 'a'; Externe Variable ch void getachar(); void putachar(); void main() { while(ch != '\n') // Zugriff von main() auf ch { getachar(); putachar(); } } void getachar(); // Zugriff von getachar() auf ch { ch = getch(); } void putachar(); // Zugriff von putachar() auf ch { cout << ch; }