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?


  • Mod

    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?


Log in to reply