Erstellung und Aufruf einer Funktion - Wie?



  • Hallo Community,

    nach überfliegen mehrerer C Anleitungen bin ich leider immer noch nicht schlauer und wende mich nun an Leute die mir sicher weiter helfen können.

    Mein Problem:

    Ich will ein Teil meines C Programmes in eine Funktion „auslagern“. Diese Funktion soll allerdings nicht im gleichen file.c stehen sondern ein eigenes file erhalten.

    Mein Momentaniger Stand:

    Die Main Datei ist erstellt und liest einen Wert ein, für den eine Fakultaet berechnet werden soll und gibt das Ergebnis am Ende auch wieder aus.

    Die Berechnung der Fakultaet will ich auslagern.

    Benötige ich eine header Datei?

    Was macht die Header Datei?

    Wie rufe ich die Funktion korrekt auf?

    Was muss alles übergeben werden?

    Ich bin mir bewusst, dass es eine Funktion zur Fakulaetsberechung gibt, diese will ich jedoch nicht verwenden!

    Ich bin gespannt. 🙂

    Grüße
    Lorenz



  • Huhu,

    das ist recht simpel.

    /* funktion.h */
    #ifndef FUNKTION_H /*INCLUDE GUARDS*/
    #define FUNKTION_H
    
    void foo(/*...*/); /* Deklaration */
    
    void foo(/*...*/) /* Definition */
    {
        /* ... */
    }
    
    #endif
    
    /* main.c */
    #include "funktion.h"
    
    int main()
    {
         foo(); /* Aufruf */
         return 0;
    }
    


  • super!
    Danke

    Das probier ich gleich mal.



  • Soo,

    das funktioniert so weit.
    Jetzt aber noch eine Frage.
    Jetzt steht meine Funktion ja in der header Datei.
    Was nun aber wenn ich die Funktion in ein file.cpp schreibe und daraus aufrufen will?

    Laut Aufgabenstellung sollte das Funktionieren, den Sinn dahinter braucht man hier denke ich nicht suchen. Ich muss einfach durch probieren was geht.

    Danke schon mal für die Antwort



  • Hi,

    Lorenz_FH schrieb:

    Was nun aber wenn ich die Funktion in ein file.cpp schreibe und daraus aufrufen will?

    Das ist die übliche Vorgehensweise. Prototypen in *.h Dateien und die Funktionen in *.c Dateien.



  • Huhu,

    Genau, man betrachtet es als schönen Stil, wenn man die Deklarationen in .h Dateien schreibt und die Definitionen in .c Dateien.

    Hier wieder ein Example:

    /* funktionen.h */
    #ifndef FUNKTIONEN_H
    #define FUNKTIONEN_H
    
    void foo_1(...);
    void foo_2(...);
    void foo_3(...);
    /*...*/
    #endif
    
    /* funktionen.c */
    #include "funktionen.h"
    
    void foo_1(...)
    {
         /*...*/
    }
    
    void foo_2(...)
    {
        /*...*/
    }
    
    void foo_3(...)
    {
       /*...*/
    }
    
    /* main.c */
    #include "funktionen.h"
    
    int main()
    {
         foo_1(...);
         foo_2(...);
         foo_3(...);
         return 0;
    }
    

    "Verschönert" den Code etwas (:



  • yeah jetzt geht das so wie ich mir das vorgestellt habe. Vielen Dank!



  • Genau, man betrachtet es als schönen Stil, wenn man die Deklarationen in .h Dateien schreibt und die Definitionen in .c Dateien.

    Und man spart sich unter Umständen eine Menge Ärger:
    http://www.c-plusplus.net/forum/viewtopic-var-t-is-254858.html
    🙂



  • Ich noch mal,

    da sich die Frage auf die Sache von gestern aufbaut, wollte ich kein neuen Strang auf machen.

    Wenn ich an meine ausgelagerte Funktion nun ein Feld zb.: a[3] übergeben will, muss ich dann a[0],a[1],a[2] oder geht das auch mit weniger schreib aufwand und übersichtlicher? Die Gleichefrage stellt sich für den Rückgabewert.

    Danke
    Grüße
    Lorenz



  • Huhu,

    nein, das würde nicht gehen, denn:

    void swap ( int a[] )
    {
        /* ... */
    }
    
    int main()
    {
         int a[] = {2,3,4,5,6};
         foo(a[0],a[1],a[2]);  /* FEHLER! - swap akzeptiert nur ein Argument! */
    }
    

    Das ganze müsste so aussehen:

    void swap( int a[] )
    {
        /* ... */
    }
    
    int main()
    {
         int a[] = { 2,3,1,3,4} ;
         swap(a); /* NUR DEN ARRAYNAMEN */
    }
    

Log in to reply