14.10 Zeiger auf Funktionen
Mit den Zeigern können Sie auch auf Maschinencode von anderen Funktionen zeigen, welche schließlich ebenfalls eine Anfangsadresse im Speicher besitzen. Ein einfaches Beispiel dazu:
/* ptr_func1.c */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int (*ptr) (const char*, ...);
ptr=printf;
(*ptr)("Hallo Welt\n");
return EXIT_SUCCESS;
}
Jetzt eine Erklärung zur folgenden Schreibweise:
int (*ptr)(const char*, ...);
Dies ist ein Zeiger auf eine Funktion, welche einen variablen, langen String erhält und einen int-Wert zurückgibt. Die Funktion printf() zum Beispiel ist eine solche Funktion:
int printf (const char*, ...);
Daher bekommt der Zeiger die Adresse dieser Funktion mit folgender Anweisung:
ptr = printf;
Jetzt können Sie die Funktion printf() mit dem Zeiger aufrufen:
(*ptr)("Hallo Welt\n");
Die erste Klammerung des Zeigers ptr ist wichtig. Würden Sie diese weglassen, dann würden Sie ptr als eine Funktion deklarieren, die einen int-Zeiger zurückgibt. Sie können den (Funktions-)Zeiger auch auf eine andere Funktion zeigen lassen, mit demselben Rückgabewert und dem- bzw. denselben Argument(en). Hier das Listing von eben mit weiteren Adressierungen:
/* ptr_func2.c */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int (*ptr)(const char*, ...);
int zahl;
ptr=printf;
(*ptr)("Bitte eine Zahl eingeben: ");
ptr=scanf;
(*ptr)("%d",&zahl);
ptr=printf;
(*ptr)("Die Zahl lautet %d\n",zahl);
return EXIT_SUCCESS;
}
Dieses Beispiel sollte natürlich keine Schule machen und Ihnen nur zeigen, wie Sie mit Zeigern auf Funktionen zeigen können.
Zeiger auf Funktionen können ganz nützlich sein. Sie können die Zeiger in einem Feld speichern und eine Sprungtabelle daraus machen. Damit ist gemeint, dass die einzelnen Funktionen mit einem Feldindex angesprochen werden können, ähnlich wie bei den Stringtabellen – also ein Array von Funktionen, wenn Sie so wollen. Dazu soll das Listing von eben wieder herhalten:
/* ptr_func3.c */
#include <stdio.h>
#include <stdlib.h>
#define INPUT 0
#define OUTPUT 1
int main(void) {
int (*ptr[])(const char *, ...) = { scanf, printf };
int zahl;
(*ptr[OUTPUT])("Bitte eine Zahl eingeben: ");
(*ptr[INPUT])("%d",&zahl);
(*ptr[OUTPUT])("Die Zahl lautet %d\n",zahl);
return EXIT_SUCCESS;
}
Viel verändert hat sich hierbei nicht. Anstatt
int (*ptr)(const char*, ...);
wurde hier einfach noch ein Indizierungsoperator hinzugefügt. Am Ende befinden sich zwischen den geschweiften Klammern noch die einzelnen Funktionen, auf die Sie im Programm mithilfe des Indizierungsoperators und dem entsprechenden Index zurückgreifen können:
int (*ptr[])(const char *, ...) = { scanf, printf };
In diesem Beispiel zeigt (*ptr[0]) auf die Adresse der Funktion scanf(), und (*ptr[1]) zeigt auf die Funktion printf(). Im Programm wurden hierbei symbolische Konstanten verwendet, um diese beiden Funktionen besser auseinander zu halten.
Voraussetzung dafür, dass diese Zeiger auf Funktionen auch funktionieren, ist immer, dass der Rückgabewert (hier vom Typ int) und der/die Parameter der Funktion (hier (const char *, ...)) übereinstimmen. Sie können hierbei nicht einfach zusätzlich z.B. die Funktion fgets() zum Einlesen von Strings anhängen:
/* falsch */
int (*ptr[])(const char *, ...) = { scanf, printf, fgets };
Die Funktion fgets() erwartet andere Argumente, hier (const char *, ...).
Wenn es möglich ist, mit Zeigern auf Funktionen der Standard-Bibliothek zu zeigen, dann ist es selbstverständlich auch möglich, mit Zeigern auf selbst geschriebene Funktionen zu zeigen.
/* ptr_func4.c */
#include <stdio.h>
#include <stdlib.h>
/* Bei Linux für math.h den Compilerflag –lm mitangeben:
* gcc –o programm programm.c –lm
*/
#include <math.h> /* sqrt() */
int addition(int zahl) {
int y;
printf("%d+>", zahl);
scanf("%d", &y);
fflush(stdin);
return zahl += y;
}
int subtraktion(int zahl) {
int y;
printf("%d->", zahl);
scanf("%d", &y);
fflush(stdin);
return zahl -= y;
}
int division(int zahl) {
int y;
printf("%d/>",zahl);
scanf("%d", &y);
fflush(stdin);
return zahl /= y;
}
int multiplikation(int zahl) {
int y;
printf("%d*>",zahl);
scanf("%d", &y);
fflush(stdin);
return zahl *= y;
}
int sqrtw(int zahl) {
double x=sqrt((double)zahl);
printf("(sqrt)%f>", x);
return (int)x;
}
int (*rechenfunk[]) (int) = {
addition, subtraktion, division, multiplikation, sqrtw
};
int main(void) {
char op;
static int zahl;
printf("no.>");
scanf("%d",&zahl);
do {
printf(" op>");
scanf("%c",&op);
fflush(stdin);
switch(op) {
case '+': printf("%d", zahl = (*rechenfunk[0])(zahl));
break;
case '-': printf("%d", zahl = (*rechenfunk[1])(zahl));
break;
case '/': printf("%d", zahl = (*rechenfunk[2])(zahl));
break;
case '*': printf("%d", zahl = (*rechenfunk[3])(zahl));
break;
case 'q': printf("%d", zahl = (*rechenfunk[4])(zahl));
break;
default : printf("op '=','+','-','/','*','q'\n");
}
} while(op != '=');
printf("Gesamtergebnis=%d\n",zahl);
return EXIT_SUCCESS;
}
Hier klicken, um das Bild zu Vergrößern
Abbildung 14.20
Zeiger auf selbst geschriebene Funktionen
Dieses Programm stellt einen kleinen Taschenrechner dar, welcher allerdings stark verbesserungswürdig ist. Es können fünf Rechenoperationen wie Addition, Subtraktion, Multiplikation, Division und die Quadratwurzel verwendet werden. Es wird so lange gerechnet, bis das =-Zeichen eingegeben wurde. Hierzu folgt ein kurzer Trocken-Durchlauf. Nachdem das Programm gestartet wurde, sollte auf dem Bildschirm Folgendes erscheinen:
no.>
Hier geben Sie die erste Zahl ein und drücken (¢), beispielsweise die Zahl 8. Anschließend geht es in der do while-Schleife weiter. Jetzt erscheint auf dem Bildschirm:
op>
Hier muss der Rechenoperator eingegeben werden: entweder +, -, *, / oder q. In diesem Beispiel soll es eine Addition sein, also geben Sie das +-Zeichen ein und drücken (¢). Danach wird das Zeichen im switch-Schalter darauf geprüft, ob es sich dabei um ein gültiges Zeichen handelt. In diesem Fall wäre das:
case '+': printf("%d", zahl = (*rechenfunk[0])(zahl));
Hiermit wird die Rechenfunktion mit dem Index [0] aufgerufen. Dieser Funktion wird als Parameter der Wert der Variablen zahl übergeben. Ein Blick auf die Funktionstabelle:
int (*rechenfunk[]) (int) = {
addition, subtraktion, division, multiplikation, sqrtw
};
Die Rechenfunktion mit dem Index [0] ist die Funktion addition. subtraktion hat den Index [1], division den Index [2] usw.
In der Funktion addition() geben Sie dann eine Zahl ein, mit welcher der übergebene Wert addiert werden soll, beispielsweise die Zahl 2, und anschließend drücken Sie wieder (¢):
10 op>
Jetzt kann ein weiterer Operator verwendet oder mit dem =-Zeichen das Programm beendet werden.
|
