Mehrere Datein



  • Ich habe mal wieder ein Problem...
    Ich würde gerne 3 Datein miteinander verbinden

    1x Main.cpp
    1x Prototypen.h
    1x Funktionen.cpp

    Und ich bekomme die 3 nicht miteinander verbunden...

    Main.cpp

    #include "Prototypen.h"
    //Main Funktionen (Funktionen aufrufen)
    

    Prototypen.h

    //Oder müssen hier die Sachen includiert werden?
    #ifndef PROTOTYPEN_H_INCLUDED
    #define PROTOTYPEN_H_INCLUDED
    //Ich weiß das hir die Prototypen rein gehören, aber was hier includiert werden //muss habe ich keine Anuhng.
    #endif
    

    Funktionen.cpp

    #include "Prototypen.h"
    //Funktionen
    

    Ich stehe voll aufm Schlauch 😃
    Hat jemand einen nützlichen Link, oder macht sich die Mühe mir das kurz zu erklären? 🙂



  • Ist genau so richtig, bis auf die Namensgebung.

    Gewöhnlich schreibt man ja eine Klasse oder mehrere Funktionen, die logisch zusammen gehören; d.h. du hast einen Überbegriff, der den Zusammenhang beschreibt. Und so nennt man beide Dateien auch Dann. Die Funktions-/Klassendeklarationen schreibst du dann in die Header-Datei, welche sowohl dort inkludiert wird wo die Funktionen benutzt werden /z.b. in main.cpp) als auch in der CPP-Datei, wo du sie letztlich implementierst.

    Beispiel:

    // Main.cpp
    include "Printings.h"
    
    int main()
    {
        print("Foo Test Example");
    }
    
    // Printings.h
    #ifndef Printings_h_
    #define Printings_h_
    
    #include <string> // fürstd::string
    
    void print(std::string const& line);
    
    #endif // Printings_h_
    
    // Printings.cpp
    #include "Printings.h"
    #include <iostream>
    
    void print(std::string const& line)
    {
        std::cout << line << std::endl;
    }
    

    Verständlicher?



  • In Prototypen.h kommen die Deklarationen, in Prototypen.cpp die Definitionen.
    Beispiel:

    // Prototypen.h
    extern int i; // Variablendeklaration
    void func(int foo); // Funktionsdeklaration
    class foo // Klassendefinition, gehört aber trotzdem in den Header
    {
    public:
      void memfunc(); // Memberfunktionsdeklaration
    };
    using bar = char; // Typdef, keine Definition notwendig
    // Prototypen.cpp
    #include "Prototypen.h"
    
    int i; // Variablendefinition
    void func(int foo) // Funktionsdefinition
    {
      ...
    }
    
    void foo::memfun() // Memberfunktionsdefinition
    {
    ...
    }
    

    Bei Templatefunktionen muss auch die Definition in dem Header, genauso wie bei constexpr und inline Funktionen!
    Du inkludierst nun im Header die Dateien, die für die Deklaration benötigt werden.

    void foo(bar a); // der Compiler muss wissen, dass bar ein Typ ist
    

    Es reicht dem Compiler aber aus zu wissen, dass bar ein Typ ist, nicht wie der Typ aufgebaut ist, also:

    class bar; // Forward-declaration reicht aus
    void foo(bar a);
    

    Weiteres Beispiel:

    class foo
    {
    private:
      bar1 *a;
      bar2 b;
    };
    

    Der Compiler muss anhand der Klassendefinition in der Lage sein, die Größe von foo zu wissen. Er weiß, wie groß ein Pointer ist, also reicht die Deklaration von bar1 aus. Er weiß allerdings nicht, wie groß bar2 ist, also muss er hierfür die Definition kennen:

    #include "bar2.h"
    
    class bar1;
    
    class foo
    {
    private:
      bar1 *a;
      bar2 b;
    };
    

    Bei der Definition werden wie gewohnt alle Header inkludiert, aus denen etwas verwendet wird. IdR reichen dafür allerdings keine Forwarddeclarations aus, da müssen dann die Header inkludiert werden.

    #include "bar.h" // Compiler muss wissen, dass bar eine Memberfunktion func hat
    #include <iostream> // Compiler muss std::cout kennen
    
    void foo(bar a)
    {
      a.func();
      std::cout << "Hallo Welt!";
    }
    


  • Und wieder ein großes Danke! 😃
    Es klappt.


Log in to reply