Nun habe ich aber 2 Fragen:
Man kann in der Header-Datei dann nur Zeiger verwenden. Also müssen diese Objekte immer mit new angelegt werden (da sie ja das Objekt sonst nach dem der Scope - meist Konstruktor - verlassen wird, weg ist).
Es heißt ja, dass man wann immer es möglich ist den stack nutzen soll. Dies ist damit aber nicht möglich.
Gibt es eine Vorwärtsdeklaration mit dem ich wie gewohnt auf dem Stack anlegen kann (KLASSE a; anstelle von KLASSE* a; und im Programm a = new KLASSE(); ).

Zweites Problem:
Ich habe in einer Klasse, die ich bis jetzt via Vorwärtsdeklaration im Header eingebunden habe, ein struct. Von diesem struct soll nun ein Objekt in meinem Projekt gespeichert werden.
Also würde ich gerne in der Header Datei folgendes haben:

class KLASSE;

class CurrentProject
{
private:
	STRUCT structVonKlasse;
}
}

Geht natürlich nicht, da die Struktur STRUCT bei dem Beispiel nicht bekannt ist - woher soll der Kompilier wissen, dass diese in der Klasse KLASSE definiert wird. Wie kann ich das dem Kompilier noch sagen?

Danke

Prinzipiell würde ich nicht versuchen, IMMER mit Vorabdeklarationen zu arbeiten, sondern diese dann zu verwenden, wenn es möglich ist. Und das ist es immer dann, wenn Member nur Zeiger oder Referenzen sind, für Funktionsparameter geht es auch immer.

Hallo,
mir wurde hier in der Firma gesagt, dass ich wann immer es möglich ist, Vorwärtsdeklaration nutzen soll (also in der Header-Datei kein "#include KLASSE" sondern nur class KLASSE;), damit beim Einbinden des Projektes keine Probleme mit dem Linker kommen (man weiß ja nie, von wem, wann und wo das Projekt wieder genutzt wird). Ok, das versteh ich, da der relative Pfad ja immer von dem Pfad des Hauptprojektes ausgeht und nicht von dem Projekt in dem man es geschrieben hat.

Das klingt n bissel komisch. Deklaration einer Klasse statt per #include die Definition zu holen hat primär den Vorteil, dass eine Übersetzungseinheit von weniger Dateien abhängt. Das ist dann gut, wenn etwas geändert wird. Alles, was davon abhängt, müsste neukompiliert werden. Eine Klassen-DEKLARAtion reicht aber nicht immer aus. Daher wirst Du in einigen Fällen gezwungen sein, Dir per #include die DEFINItion der Klasse zu holen.

Xenya schrieb:

Nun habe ich aber 2 Fragen:
Man kann in der Header-Datei dann nur Zeiger verwenden.

Dem Compiler ist es schnurz, WO etwas steht. #include macht einfach nur eine rohe Textersetung. Ja, für gewisse Operationen muss ein Typ vollständig bekannt sein. Bei einer Deklaration wie

class Dingsbums;

wird dem Compiler nur gesagt, dass es eine Klasse mit diesem Namen gibt. Der Typ ist erstmal unvollständig. C++ erlaubt es dir aber eingeschränkt mit Zeigern T* und Referenzen T& zu arbeiten, wobei T unvollständig ist.

Xenya schrieb:

Also müssen diese Objekte immer mit new angelegt werden (da sie ja das Objekt sonst nach dem der Scope - meist Konstruktor - verlassen wird, weg ist).
Es heißt ja, dass man wann immer es möglich ist den stack nutzen soll. Dies ist damit aber nicht möglich.
Gibt es eine Vorwärtsdeklaration mit dem ich wie gewohnt auf dem Stack anlegen kann (KLASSE a; anstelle von KLASSE* a; und im Programm a = new KLASSE(); ).

Gibt es nicht. Und "new KLASSE()" funktioniert auch nicht, wenn KLASSE unvollständig ist.

Xenya schrieb:

Zweites Problem:
Ich habe in einer Klasse, die ich bis jetzt via Vorwärtsdeklaration im Header eingebunden habe, ein struct. Von diesem struct soll nun ein Objekt in meinem Projekt gespeichert werden.
Also würde ich gerne in der Header Datei folgendes haben:

class KLASSE;

class CurrentProject
{
private:
	STRUCT structVonKlasse;
}
}

Geht natürlich nicht, da die Struktur STRUCT bei dem Beispiel nicht bekannt ist - woher soll der Kompilier wissen, dass diese in der Klasse KLASSE definiert wird. Wie kann ich das dem Kompilier noch sagen?

Gar nicht. Die Definition von KLASSE muss bekannt sein, so dass KLASSE::STRUCT als Typ nutzbar ist. STRUCT darf eh nicht unvollständig sein, wenn Du diesen Typ für ein Datenelement un CurrentProject verwenden willst.

Hallo,
mir wurde hier in der Firma gesagt, dass ich wann immer es möglich ist, Vorwärtsdeklaration nutzen soll (also in der Header-Datei kein "#include KLASSE" sondern nur class KLASSE;), damit beim Einbinden des Projektes keine Probleme mit dem Linker kommen (man weiß ja nie, von wem, wann und wo das Projekt wieder genutzt wird).
Ok, das versteh ich, da der relative Pfad ja immer von dem Pfad des Hauptprojektes ausgeht und nicht von dem Projekt in dem man es geschrieben hat.

Bullshit. Der Linker hat erst mal gar nichts zu tun, der Compiler braucht aber die Bezeichner, um klarzukommen (deshalb reicht in einer Deklaration für eine DLL ja auch nur der Rückgabetyp, die Konvention, der Name, die Parameter und der Verweis, dass die Funktion ihre Definition von außen bekommt). Wieso bringen die Linker und Compiler durcheinander, das sind zwei voneinander unabhängige Programme ...

Xenya schrieb:

Nun habe ich aber 2 Fragen:
Man kann in der Header-Datei dann nur Zeiger verwenden. Also müssen diese Objekte immer mit new angelegt werden (da sie ja das Objekt sonst nach dem der Scope - meist Konstruktor - verlassen wird, weg ist).
Es heißt ja, dass man wann immer es möglich ist den stack nutzen soll. Dies ist damit aber nicht möglich.

1. Du kannst auch auf Objekte auf dem Stack zeigen, wenn du lustig bist. Musst nur das Design ein bisschen verändern:

class B;
class A
{
public:
    A(B*pPointer)
    {
        Pointer=pPointer;
        //Machen wir noch einen kleinen Scherz, lassen wir die Objekte
        //auf den jeweils anderen zeigen.
        pPointer->Pointer=this;
    }
private:
    B*Pointer;
};

class B
{
public:
    //Kein A-Objekt zum ERSTELLEN notwendig.
    A*Pointer
};

int main()
{
    B MyB;
    A MyA(&B);//Adresse von Objekt auf dem Stack
    return 0;
}

2. Den Heap sollte man nicht grundsätzlich meiden. Manche Sachen lassen sich eben nur mit dynamischer Speicherverwaltung realisieren.

Was bringen die euch eigentlich bei?

Xenya schrieb:

class KLASSE;

class CurrentProject
{
private:
	STRUCT structVonKlasse;
}
}

Geht natürlich nicht, da die Struktur STRUCT bei dem Beispiel nicht bekannt ist - woher soll der Kompilier wissen, dass diese in der Klasse KLASSE definiert wird. Wie kann ich das dem Kompilier noch sagen?

class A;
class B
{
     //Zeiger
     A*Pointer;
};

class A
{
     //Objekt
     B Object;
};

Nix zu danken!

class A;
class B
{
     //Zeiger
     A*Pointer;
};

class A
{
     //Objekt
     B Object;
};

Nix zu danken!

Sehe gerade, ist selbst Bullshit, was ich geschrieben habe.

Es ist nicht möglich, auf einen noch nicht deklarierten Typ zuzugreifen - wo kämen wir denn da hin?