12.10 Zeiger auf Funktionen

Mit den Zeigern können Sie auch auf Maschinencode von anderen Funktionen zeigen, die 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, die 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 sehen Sie 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. Statt

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 auseinanderzuhalten.

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 das Compiler-Flag -lm mit angeben:
 *     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;
}

Abbildung 12.20 Zeiger auf selbst geschriebene Funktionen

Dieses Programm stellt einen kleinen Taschenrechner dar, der 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. Sehen Sie sich dazu die Funktionstabelle an:

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 der 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.

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.