#includes in der cpp

Fuchs aus dem Wald

Mich würde interessiert grade ob es zu Schnittstellen Problemen kommen kann wenn man seine .h in einer anderen .h included.
Mir wurde das so erklärt das wenn ich:

class A{
  void bla();
  void bla2();
}

#include "a.h"
class B{
  blabla();
}

Nun soll gebaut und installiert werden und dann neu mit der unten stehenden A;
Wenn ich nun class a abändere soll das zu Problemen führen! Kann sowas überhaupt passieren?
Hinzufügen soll ok sein aber sowas nicht:

class A{
  void bla();
}

Mir wurde das auch versucht zu demonstrieren was dann einen

lookup error undefined symbol

fehler hervor gerufen hat.

Vielleicht könnt ihr mich da noch mal genauer aufklären.

Kompletter Blödsinn. Vielleicht ist das Makefile oder das Äquivalent dazu in deiner IDE zu dumm um das zu merken, aber das ist kein Problem der Schnittstelle. Nach einem Rebuild funktionierts.

Skym0sh0

Hä?

Jetzt mal ohne Spass, mein Textstil ist ja auch sehr gewöhnungsbedürftig. Aber du achtest hier gerade weder auf Zeichensetzung, noch gedankliche Pausen etc. Grammatik ist auch nicht so die Stärke von dem Post.

Bitte überarbeite die Fragestellung nochmals komplett.

Nachtrag: Inkludierst du einen header in einen anderen gibt das keinerlei Probleme. Auch wenn du Änderungen reinbringst gibt das keine Probleme, solange da keine Fehler durch erzeugt werden.

Fuchs aus dem Wald

Tut mir leid. Ich versuche es noch einmal.

Also mir wurde gesagt das ich meine includes mit "lalala.h"(also die mit " ") lieber in die .cpp schreiben soll, da es sonst bei Änderungen zu Problemen in der Header kommen kann.
Ich hoffe so kann man das verstehen.

Skym0sh0

Aha, ok.

Da geb ich dir ein ganz klares Jain.

In den Header inkludierst du, was du inkludieren musst, damit Symbole auch deklariert sind. Bsp:

// A.h
class A { /* ... */  };

// B.h
#include "A.h"

class B
{
    A myA; // hierfür brauchst du A.h
};

Anders sieht das aus, wenn du kein Objekt speichern willst, sondern nur einen darauf:

// A.h
class A { /* ... */  };

// B.h

class A; // Forward Declaration

class B
{
    A * myA; // hierfür brauchst die Forward Declaration, aber du brauchst nicht die ganze Definition von A
};

(So umgeht man auch zyklische Abhängigkeiten, so sie denn auftreten!)

In die dazugehörigen Source-Dateien musst du in jedem Fall direkt (include x) oder indirekt (Andere Datei inkluden, wo die benötigte Datei schon inkludiert wurde) die benötigte Datei inkludieren.

Source Dateien included man nirgens hin (es sei denn du weisst, was du machst und du hast einen guten Grund).

Natürlich, je größer dein Projekt, je mehr Header Dateien die sich untereinander inkludieren, desto länger dauert das Compilen auch, logischerweise. Beispiel:

(die Pfeile "a --> b" bedeuten, dass a in b inkludiert wird)

A.h --> B.h
A.h --> C.h
C.h --> D.h
D.h -->main.cpp

Änderst du nun irgendetwas in A.h muss natürlich alles andere neu kompiliert werden (B.h, C.h, D.h, Main.cpp), sowie alle weiteren Dateien in denen eine dieser Dateien inkludiert wird.

Und das ist auch der Grund warum ich Jain sage. Man sollte nicht jeden Müll überall hin inkludieren. Und auch mit zyklischen Abhängigkeiten musst du aufpassen.

Fuchs aus dem Wald

Skym0sh0 schrieb:

Anders sieht das aus, wenn du kein Objekt speichern willst, sondern nur einen ?Zeiger? darauf:
// A.h
class A { /* ... */  };
// B.h

class A; // Forward Declaration

class B
{
    A * myA; // hierfür brauchst die Forward Declaration, aber du brauchst nicht die ganze Definition von A
};
(So umgeht man auch zyklische Abhängigkeiten, so sie denn auftreten!)

Wenn ich das richtig verstanden habe sollte man zyklische Abhängigkeiten vermeiden.
Ansonsten so:

class A{
  void lala();
}

#include "A.h"

class B{
  A myA;
}

class A;

class C{
  A* myA;
  void blaa();
}

//C.cpp
#include "A.h" //ist das nun nötig?
#include "B.h"
void bla(){
  B* myB;
}