Typedef bei Funktionen?
-
Hallo,
ich habe funktion a:
int a(int x) { return x; }
nun will ich funktion b, die soll aber eine art typedef auf funktion a sein, also so:
typedef a(int x) b(int y);
so geht das aber nicht.
Welche anderen Möglichkeiten gibts da?
-
eine Funktion ist kein Typ
aber du könntest einen Funktionszeiger benutzen
oder ein Makro
oder eine Funktion schreiben die die andere Funktion aufruft
-
wie funktioniert das mit dem makro und dem funktionszeiger?
beim makro einfach ein #define b(int x) a(int x)
?
-
int (*b)(int) = a; #define b(x) a(x)
-
gary1195 schrieb:
int (*b)(int) = a; #define b(x) a(x)
ließe sich im 1. fall die funktion b ganz normal benutzen?
-
und wie müsste es aussehen, wenn funktion b einen pointer zurückgibt?
-
Ja, b ließe sich ganz normal benutzen.
b(5)
Mit Pointer:
int * (*b) (int);
Aber was willst du machen?
-
ok, ich glaub, makros sind einfacher.
-
#include <stdio.h> int identitaet(int x) { return x; } int quadrat(int x) { return x*x; } int dreieckszahl(int x) { return x*(x+1)/2; } int kubus(int x) { return x*x*x; } typedef int soNeIntNachIntFunktion(int x);//Das ist jetzt der Typ dieser Funktionen int main() { soNeIntNachIntFunktion *meineFunktion = &kubus;//meineFunktion ist ein //Zeiger auf soNeIntNachIntFunktion. Er zeigt auf kubus. printf("%p\n",meineFunktion);//Dort liegt die Funktion im Speicher. int a=5; int ka=(*meineFunktion)(a);//ka sei {da wo meineFunktion hinzeigt}(5). //also ka sei kubus(5); printf("%d\n",ka);//125, stimmt return 0; }
Und jetzt kommt C-Zauberei.
Tatsächlich kann man in C sogar anders schreiben, man kann zum Beispiel kubus nur entweder aufrufen, also kubus(...) schreiben oder die Adresse der Funktion ziehen mit &kubus. Darum hat man festgelegt, daß man das & sogar weglassen darf, wenn eine Funktion nicht aufgerufen wird. Genauso andersrum, beim Aufruf über einen Funktionszeiger braucht man nicht (*funczeiger)(5) zu schreiben, sondern funczeiger(5) reicht.
Das führt zu Folgendem#include <stdio.h> int identitaet(int x) { return x; } int quadrat(int x) { return x*x; } int dreieckszahl(int x) { return x*(x+1)/2; } int kubus(int x) { return x*x*x; } typedef int soNeIntNachIntFunktion(int x);//Das ist jetzt der Typ dieser Funktionen int main() { soNeIntNachIntFunktion *meineFunktion = kubus;//meineFunktion ist ein //Zeiger auf soNeIntNachIntFunktion. Er zeigt auf kubus. printf("%p\n",meineFunktion);//Dort liegt die Funktion im Speicher. int a=5; int ka=meineFunktion(a);//ka sei {da wo meineFunktion hinzeigt}(5). //also ka sei kubus(5); printf("%d\n",ka);//125, stimmt return 0; }
Außerdem wissen viele nicht, daß man den Typ der Funktion typedeffen kann, weil man Funktionen eben nicht in Variablen stecken kann, sondern nur Funktionszeiger.
Sie schreiben also im Prinzip
#include <stdio.h> int identitaet(int x) { return x; } int quadrat(int x) { return x*x; } int dreieckszahl(int x) { return x*(x+1)/2; } int kubus(int x) { return x*x*x; } typedef int soNeIntNachIntFunktion(int x);//Das ist jetzt der Typ dieser Funktionen typedef soNeIntNachIntFunktion* soNeIntNachIntFunktionZeiger; int main() { soNeIntNachIntFunktionZeiger meineFunktion = kubus;//meineFunktion ist ein //Zeiger auf soNeIntNachIntFunktion. Er zeigt auf kubus. printf("%p\n",meineFunktion);//Dort liegt die Funktion im Speicher. int a=5; int ka=meineFunktion(a);//ka sei {da wo meineFunktion hinzeigt}(5). //also ka sei kubus(5); printf("%d\n",ka);//125, stimmt return 0; }
Aber sie schreiben nicht beide typedefs, sondern fassen die zusammen. Dann muss man noch eine Klammer setzten, weil () normalerweise stärker bindet als *.
#include <stdio.h> int identitaet(int x) { return x; } int quadrat(int x) { return x*x; } int dreieckszahl(int x) { return x*(x+1)/2; } int kubus(int x) { return x*x*x; } typedef int (*soNeIntNachIntFunktionZeiger)(int x);//Das ist jetzt der Typ dieser Funktionen int main() { soNeIntNachIntFunktionZeiger meineFunktion = kubus;//meineFunktion ist ein //Zeiger auf soNeIntNachIntFunktion. Er zeigt auf kubus. printf("%p\n",meineFunktion);//Dort liegt die Funktion im Speicher. int a=5; int ka=meineFunktion(a);//ka sei {da wo meineFunktion hinzeigt}(5). //also ka sei kubus(5); printf("%d\n",ka);//125, stimmt return 0; }
Das ist schon das ganze Geheimnis an Garys
int (*b)(int) = a;
Normalerweise sind Funktionszeiger den Makros echt zu bevorzugen, weil Makros ganz unpraktisch werden, wenn das Programm mal größer wird und man viele davon bräuchte.
-
...
-
ja, und was ist, wenn eine funktion mehr parameter braucht als die andere, man aber "default-parameter" geben möchte?
z.b.:
int func_a(int a, int b) { return (a+b); }
nun möchte ich einen funktionszeiger auf "func_a", der aber nur einen parameter benötigt, und parameter b standardmäßig auf 1 setzt.
also dass durch den funktionszeiger nur a verändert werden kann und b=1 standardmäßig übergeben wird.geht das?
-
frrrrage schrieb:
ja, und was ist, wenn eine funktion mehr parameter braucht als die andere, man aber "default-parameter" geben möchte?
z.b.:
int func_a(int a, int b) { return (a+b); }
nun möchte ich einen funktionszeiger auf "func_a", der aber nur einen parameter benötigt, und parameter b standardmäßig auf 1 setzt.
also dass durch den funktionszeiger nur a verändert werden kann und b=1 standardmäßig übergeben wird.geht das?
Nein. Nichts hindert dich aber, eine entsprechende Funktion zu schreiben und den Zeiger darauf zeigen zu lassen.
int func_a_(int a) { return func_a( a, 1 ); }
-
Dann brauch ich aber keinen Zeiger mehr... geht das nicht mit Funktionszeigern?
-
frrrrage schrieb:
Dann brauch ich aber keinen Zeiger mehr... geht das nicht mit Funktionszeigern?
Was soll der Quatsch?
Zum Einfüllen von Default-Parametern ist der Aufrufer verpflichtet, woher soll er zur Laufzeit an einem simplen 32-bittigen Zeiger erkennen, welche beliebig große Veranstaltung nötig ist, Defaultparameter bereitzustellen?