Zeiger auf Funktionen in C mit Parameterliste



  • Hi Leute,
    ich habe da eine Frage zu Funktionszeigern.

    Und zwar folgender Code:

    #include <stdio.h>
      
      int zfunc()
      {
          printf("zfunc ausgeführt!\n");
          return 0;
      }
      
      int main()
     {
         int (*f)();
     
         f = &zfunc;
     
         printf("Rufe f, den pointer auf zfunc, auf:\n");
         f();
     
         return 0;
     } 
    
    

    Der Code ist zwar verständlich. Aber für mich nur auf dem ersten Blick.
    Möchte ich nun eine Funktion mit Parameterliste erstellen, klappt's nach dem obigen Schema nicht!

    Beispiel:

    
    #include <stdio.h>
    
      int zfunc(int* i)
      {
          printf("zfunc ausgeführt!\n");
          return 0;
      }
    
      int main()
     {
    
    
         int a = 5;
    
         int (*f)(int*)=&a;
    
          //&zfunc;
    
         printf("Rufe f, den pointer auf zfunc, auf:\n");
         f(int*) = &zfunc(&a);
         printf("un nochma %d", *f);
    
         return 0;
     }
    
    

    Wenn ich "f(int*) = &zfunc(&a);" durch "f = zfunc(&a);" ersetze, funktioniert es zwar. Aber das scheint ja nach dem Beispiel nicht Sinn und Zweck zu sein.

    Ich hoffe ihr könnt mir weiterhelfen und mir ggf. ein paar Links im Thread da lassen.

    Viele Grüße



  • Oh, sorry 4 Doppelpost.

    Außerdem rufe ich in meinem fast funktierendem Beispiel nicht "f()" auf.



  • @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    klappt's nach dem obigen Schema nicht!

    ist keine Fehlerbschreibung



  • @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    int ( *f )(int*)=&a;

    Warum sollte ein Funktionspointer die Adresse eines Integers annehmen?

    Edit: Sterne sichtbar



  • @manni66 sagte in Zeiger auf Funktionen in C mit Parameterliste:

    @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    int ( *f )(int*)=&a;

    Warum sollte ein Funktionspointer die Adress einer Integers annehmen?

    Oh, ja das habe ich schon geändert. Da steht jetzt: int (*f)(int)=&a;
    Ich dachte Anfangs, dass das notwendig wäre auch gleichzeitig einen Zeiger vom Typ int zu deklarieren, weil ich davon ausging, dass der Funktionszeiger "int (*f)(...)" auch zugleich eine Art "Prototyp-Kopie" zu der zu verweisenden Funktion darstellen soll. Dem scheint aber nicht so gewesen zu sein.

    Ich habe jetzt folgendes hinzugefügt bzw. ersetzt:

    f = &zfunc;
         (*f)(&a);
    

    Alerdings wird scheinbar die Funktion schon mit "f = &zfunc;" aufgerufen, weshalb "(*f)(&a);" nicht mehr notwendig wäre.
    Aber ich denke "(*f)(&a);" ist trotzdem notwendig...

    Edit: UUUPS!!! Stimmt nicht!!! (*f)(&a) ruft die Funktion auf!!!

    Ich glaube das ist des Rätsels Lösung!!!



  • @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    Da steht jetzt: int (*f)(int)=&a;

    Und was soll das jetzt an der Fragestellung ändern?

    @manni66 sagte in Zeiger auf Funktionen in C mit Parameterliste:

    Warum sollte ein Funktionspointer die Adresse eines Integers annehmen?



  • Du mußt es analog wie bei deinem Beispiel ohne Parameter machen, nur daß du sowohl bei der Funktionszeigerdeklaration als auch beim Aufruf der Funktion (über den Funktionszeiger) den Parameter angibst:

    int a = 5;
    int (*f)(int *);
    
    f = &zfunc;
    
    f(&a);
    

    (die beiden mittleren Zeilen kannst du auch zu int (*f)(int *) = &zfunc zusammenfassen)

    PS: Bei einer Funktion kannst du auch den Adreßoperator & weglassen, also f = zfunc;



  • @manni66 sagte in Zeiger auf Funktionen in C mit Parameterliste:

    @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    Da steht jetzt: int (*f)(int)=&a;

    Und was soll das jetzt an der Fragestellung ändern?

    @manni66 sagte in Zeiger auf Funktionen in C mit Parameterliste:

    Warum sollte ein Funktionspointer die Adresse eines Integers annehmen?

    Wenn ich einen Funktionspointer definiere, dann sollte diesem Funktionspointer - so dachte ich - auch die Adresse eines int-Wertes zugewiesen werden. In dem Fall "int 5".
    Daher dachte ich, dass die Funktion erst wirklich was mit "&a" anfangen könnte, wenn ich auch den int-Wert als Zeiger deklariere.
    Aber dem Scheint nicht so zu sein.
    Es funktioniert komischerweise beides.
    Also einmal mit (*f)(int*) und einmal mit (*f)(int).
    Weshalb das so ist kann ich mir nicht erklären.

    So sieht jetzt also mein bisheriges Beispiel aus:

     
    #include <stdio.h>
    
      int zfunc(int* i)
      {
          printf("zfunc ausgeführt!\n");
          printf("Test %d \n" , *i);
          return 0;
      }
    
      int main()
     {
    
    
         int a = 5;
    
         int (*f)(int)=&a;
    
          //&zfunc;
    
         printf("Rufe f, den pointer auf zfunc, auf:\n");
         f =zfunc(&a);
         printf("un nochma %d", *f);
    
         return 0;
     }
    
    
    

    Edit: Sternchen Edit


  • Mod

    Warnungen aktivieren! Immer, keine Ausreden! Der Compiler möchte laut aufschreien bei int (*f)(int*)=&a;, aber die Regeln der Sprache sagen, dass er es trotzdem machen muss. Aber er darf dir über Warnungen sagen, dass er den Ausdruck für Quatsch hält.

    Ebenso all deine Versuche, die Funktion später aufzurufen:
    f ist ein Funktionszeiger. Und dem willst du nun das int-Ergebnis deiner Funktion zuweisen?

    Und beim printf geht's weiter: Wenn f ein Zeiger auf eine Funktion ist, dann ist *f logischerweise die Funktion. Und die willst du jetzt ausgeben?

    Du hast ein Verständnisproblem mit den Begriffen:
    zfunc ist eine Funktion. Die kann man aufrufen, aber zfunc ist nicht der Aufruf.

    zfunc(irgenwas) ist ein Aufruf der Funktion zfunc. Der kann irgendwas zurück geben, in diesem Fall einen int.

    f ist bei dir ein Zeiger auf eine Funktion mit einer gewissen Signatur. Dieser Zeiger hat einen Wert, in diesem Fall, dass f auf zfunc zeigt. Aber f ist kein Aufruf der Funktion zfunc!

    *f ist der Zeiger f derefernziert, also logischerweise die Funktion zfunc. Aber es ist auch kein Aufruf der Funktion zfunc

    Wenn *f die Funktion zfunc ist, dann ist (*f)(irgendwas) logischerweise ein Aufruf der Funktion zfunc. Und das hat dann wieder einen in-Rückgabewert.



  • @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    auch die Adresse eines int-Wertes zugewiesen werden

    Ich bin mir ziemlich sicher, dass du auch nicht im Ansatz weisst, was du da eigentlich machst.



  • @manni66 sagte in Zeiger auf Funktionen in C mit Parameterliste:

    @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    auch die Adresse eines int-Wertes zugewiesen werden

    Ich bin mir ziemlich sicher, dass du auch nicht im Ansatz weisst, was du da eigentlich machst.

    Danke, das bringt mich weiter.



  • @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    Danke, das bringt mich weiter.

    Würdest du mal üner die Fragen nachdenken statt einfach nur zu plappern würde es dich weiterbringen. Aber das ist die wohl zu mühsam...



  • @manni66 r-r-r-ruhig, ockergelb-Brauner.



  • @manni66 sagte in Zeiger auf Funktionen in C mit Parameterliste:

    @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    Danke, das bringt mich weiter.

    Würdest du mal üner die Fragen nachdenken statt einfach nur zu plappern würde es dich weiterbringen. Aber das ist die wohl zu mühsam...

    Ich wähle immer das Forum aus, in dem ein paar Gleichgesinnte anwesend sind (du). Fühle dich geehrt.

    An alle anderen: Danke für die wenigen nützlichen Vorschläge :).
    Das Prog lass' ich jetzt so und versuche über google herauszufinden wie es besser geht. In meinem Buch steht da nichts drinne. Und der Jürgen Wolf ist nicht der Beste...



  • @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    und versuche über google herauszufinden wie es besser geht.

    besser gehts mit std::function. ... ups. falsche Sprache.



  • @waynee sagte in Zeiger auf Funktionen in C mit Parameterliste:

    Ich glaube das ist des Rätsels Lösung!!!

    Das glaube ich nicht.

    Ich dachte Anfangs, dass das notwendig wäre auch gleichzeitig einen Zeiger vom Typ int zu deklarieren, weil ich davon ausging, dass der Funktionszeiger "int (*f)(...)" auch zugleich eine Art "Prototyp-Kopie" zu der zu verweisenden Funktion darstellen soll.

    Du hast f vom Typ Zeiger auf Funktion definiert (und nicht deklariert), ein Prototyp d.h. Funktionsprototyp ist immer nur eine Deklaration (d.h. eine Vereinbarung zwischen dir und dem Compiler ohne jegliche Codeproduktion, eine Deklaration resultiert niemals in ein Objekt, hat also keinen Typ, keine Adresse, ...)

    int main()
    {
         int a = 5;
         int (*f)();
    
         f = zfunc;
    
         printf("Rufe f, den pointer auf zfunc, auf:\n");
         f(&a);
         printf("returnwert\n%d\nAdresse von a\n%p\nAdresse f\n%p\nWert von f==Adresse von zfunc\n%p\nAdresse von zfunc\n%p",
         f(&a), (void*)&a, (void*)&f, (void*)f, (void*)zfunc);
    
         return 0;
    }
    

    https://ideone.com/NliQNw


Log in to reply