die Frage steht schon im Titel. Kann ich nicht in Datei 1 eine andere Datei includen und in dieser dann wiederrum Datei 1?

Hi

die Frage steht schon im Titel. Kann ich nicht in Datei 1 eine andere Datei includen und in dieser dann wiederrum Datei 1?

Stell dir mal folgendes vor: du hast zwei Kartons, ich nenne diese mal Karton A und Karton B. Jetzt versuche einmal Karton A zusammenzufalten und in Karton B zu legen und danach Karton B zusammenzufalten und in Karton A zu legen.
Falls du das schaffst kannst du das Prinzip auf die beiden Dateien übertragen.

Und falls schau dir mal Forwärtsdeklarationen (forward declarations) an.

Tippgeber schrieb:

Luke-2 schrieb:

Hi

die Frage steht schon im Titel. Kann ich nicht in Datei 1 eine andere Datei includen und in dieser dann wiederrum Datei 1?

Stell dir mal folgendes vor: du hast zwei Kartons, ich nenne diese mal Karton A und Karton B. Jetzt versuche einmal Karton A zusammenzufalten und in Karton B zu legen und danach Karton B zusammenzufalten und in Karton A zu legen.
Falls du das schaffst kannst du das Prinzip auf die beiden Dateien übertragen.

Und falls nicht schau dir mal Forwärtsdeklarationen (forward declarations) an.

gruss
Cartman

a.cpp:

#define A
const char *b = "hallo";
#ifndef B
#include "b.cpp"
#endif

b.cpp:

#define B
#ifndef A
#include "a.cpp"
#endif

#include<stdio.h>

int main(){ printf("%s\n", b); }

g++ -c a.cpp; g++ -c b.cpp; g++ b.o

Hi

die Frage steht schon im Titel. Kann ich nicht in Datei 1 eine andere Datei includen und in dieser dann wiederrum Datei 1?

Tippgeber hat das ja schon richtig beschrieben noch einfacher wirds wenn du dir das ganze wie eine Liste vorstellst, bei datei 1 gehts los, drin steht include 2 also wird die 2 reingehauen in der Steht include 1 also landet die 1 zum 2. mal drin usw, das ganze dreht sich dann endlos lang im Kreis bis der Compiler es aufgibt.

// ------------------------------------
// foo.hpp
#ifndef FOO_HPP_INCLUDED
#define FOO_HPP_INCLUDED

// und/oder
#pragma once

class foo
{
public:
    void bar();
    // ...
    // ...
    // ...
};

#include "foo.inl"

#endif // FOO_HPP_INCLUDED

// ------------------------------------
// foo.inl:

#ifndef FOO_INL_INCLUDED
#define FOO_INL_INCLUDED

// und/oder
#pragma once

#include "foo.hpp"
#include <conio.h>

inline void foo::bar()
{
    printf("42");
}

// ...
// ...
// ...

// ...
// ...
// ...

#endif // FOO_INL_INCLUDED

Also mit Include-Guards geht das schon.
Der Sinn? Nuja oft mal Übersichtlichkeit...

Das ist aber nicht das Selbe. Wie man in u_ser-l's Beispiel sieht packt man mit diesem Trick in jede Datei mehrere "Dateien" und kann immernoch nicht alle gleichzeitig nutzen, denn g++ a.cpp b.c++ schlägt weiterhin fehl.
Und genau darum geht es doch eigentlich, dass man eben nicht den Code von Datei 1 in dem Code von Datei 2 und umgekehrt gleichzeitig verwenden kann. Dafür gibt es doch die Forwärtsdeklaration, Zeiger und Funktionsdeklarationen

hustbaer schrieb:

Also mit Include-Guards geht das schon.
Der Sinn? Nuja oft mal Übersichtlichkeit...

Das ist aber nicht das Selbe. Wie man in u_ser-l's Beispiel sieht packt man mit diesem Trick in jede Datei mehrere "Dateien" und kann immernoch nicht alle gleichzeitig nutzen, denn g++ a.cpp b.c++ schlägt weiterhin fehl.
Und genau darum geht es doch eigentlich, dass man eben nicht den Code von Datei 1 in dem Code von Datei 2 und umgekehrt gleichzeitig verwenden kann. Dafür gibt es doch die Forwärtsdeklaration, Zeiger und Funktionsdeklarationen

Was "dasselbe" ist interessiert mich nicht.

Ich habe mich auf die ursprüngliche Fragestellung bezogen, und nicht auf u_ser-l's Posting.

Globals.h:

#ifndef GLOBALS_H
#define GLOBALS_H

#include "Controls.h"
#include "MainMenu.h"
#include "DocumentViewer.h"

class Globals {

private:
	static Controls *control_handler;
	static MainMenu *main_menu;
	static DocumentViewer *document_viewer;

public:
	static void set_ch(Controls *ch);
	static void set_mm(MainMenu *mm);
	static void set_dv(DocumentViewer *dv);

	static Controls* get_ch();
	static MainMenu* get_mm();
	static DocumentViewer* get_dv();
};

#endif

Ich include die in meiner main-datei und benutze auch Methoden aus der Klasse - ohne fehler. Wenn ich jetzt die Datei in "MainMenu.h" (welche wiederum in Globals.h includiert ist (siehe code)) includiere bekomme ich folgende fehler:

In file included from MainMenu.h (27) ,
                 from MainMenu.cpp (4) :
Globals.h (13) : error: ISO C++ forbids declaration of 'MainMenu' with no type
Globals.h (13) : error: expected ';' before '*' token
Globals.h (18) : error: 'MainMenu' has not been declared
Globals.h (22) : error: ISO C++ forbids declaration of 'MainMenu' with no type
Globals.h (22) : error: expected ';' before '*' token

Zeile 13 ist

static MainMenu *main_menu;

P.S. Eine Globals -Klasse ist nicht schöner als freie globale Variablen. Da machst du lieber einen Namensraum...

Was auch gut Funktioniert ist die globalen in den cpp Dateien zu haben statt in den headern, um sie in mehreren cpp Dateien gleichzeitig zu nutzen gibt es das Schlüsselwort extern, kannst du dir ja mal anschaun.

Das läuft etwa auf das gleiche hinaus wie static -Variablen in Klassen und hat nicht direkt mit dem Problem zu tun.

MainMenu.cpp (142) : error: incomplete type 'Globals' used in nested name specifier
MainMenu.cpp (144) : error: incomplete type 'Globals' used in nested name specifier

Das (Zeile 142 und 144) sind die einzigen beiden Zeilen wo ich was aus der Globals-Klasse verwende:

Globals::get_dv()->open_file("test.txt");
Renderer::flush_gui_objects();
Renderer::add_gui_object(Globals::get_dv());

Was der Fehler sagt versteh ich, nur wie geh ich damit um, dazu hab ich nichts gefunden.