Vorwärtsdeklaration einer Klasse in einer Klasse

Hallo,
ich würde gerne eine Klasse per Vorwärtsdeklaration im Header bekannt machen. Diese Klasse ist allerdigns eine Unterklasse.

class A
{
	class B
	{
		...
	}

	...
}

Nun habe ich schon verschiedenste Wege versucht, die Klasse B in der Klasse C vorwärts zu deklarieren:

class A
{
	public class B;
};

class C
{
	void methode(A::B para);
}

Fehler: A: 'class' Typneudefinition

namespace A
{
	class B;
};

class C
{
	void methode(A::B para);
}

Fehler: A wurde bereits als Namespace definiert

class B;

class C
{
	void methode(A::B para);
}

Fehler A keine Klasse oder Namespace.

Würde mich freuen, wenn mir wer helfen kann.

Danke

pumuckl

Das geht leider nicht. Allerdings gibts nur wenige Stellen, wo du interne Klassen wirklich brauchst - darf man fragen was du erreichen willst?

Wenn ich die Klasse B vorwärtsdeklariere und es dann in der cpp einbinde, muss das Programm, dass die lib der Klasse C einbindet, nicht das Includeverzeichnis der Klasse A mit angeben.

Da die Klasse B nur für die Funktionalität einer Methode gebraucht wird, die nicht immer aufgerufen wird, wäre es mir so lieber, da ich damit nicht alle zu dem Includeverzeichnis verdonnere.

Nexus

Das Problem hatte ich auch mal. Ich würde keine innere Klasse verwenden, das ist das Einfachste. Zur Not kurzzeitig Typsicherheit mit void* ausser Kraft setzen.

Übrigens interessant, wie ich solche Threads wiederfinde... Meistens anhand irgendwelcher Aussagen wie hier "aus dem Ärmel geschüttelt", lustigerweise kann ich mir die merken

Nexus schrieb:

Ich würde keine innere Klasse verwenden, das ist das Einfachste.

Wenn die Klassen aber Teil der Entwicklungsumgebung ist, die von externen Firmen gemacht wurde, habe ich leider keine Wahl

Nexus schrieb:

Zur Not kurzzeitig Typsicherheit mit void* ausser Kraft setzen.

Muss ich mir überlegen wie ich es nun mache, da ich das eigentlich nicht wirklich schön finde.

Auf jeden Fall Danke für die Antwort

pumuckl

Therese schrieb:

Wenn die Klassen aber Teil der Entwicklungsumgebung ist, die von externen Firmen gemacht wurde, habe ich leider keine Wahl

Doch. Ein Produkt verwenden, das so einen Murks nicht macht

Alternativ sollte ja das A::B was du übergibst schon relativ dicht an ein A gekoppelt sein (sonst wäre es wirklich GROSSER Murks was die externe Firma da veranstaltet hat). Evtl. würde es auch reichen, ein A und etwaige Informationen X, Y an die Methode zu geben, und dann erst in der Methode aus A,X und Y das B zu ermitteln?

hmm, wäre eine Möglichkeit.

In dem Fall wäre die Klasse, die die Methode aufruft das A selber

Vom Durchdenken der Problematik könnte es nun kompliziert werden aber ich versuchs noch mal aufzuzeichnen

class A
{
	public class B;
};

class C
{
	void methode(A::B para);
}

class MainClass(B para) : public A(para)
{
	...
	C objectFromC;
	objectFromC.methode(objectFromB);
}

Hoffe das stimmt nun so und ist verständlich.
Nun könnte ich es so umändern:

class A
{
	public class B;
};

class C
{
	void methode(A* para);
}

class MainClass(B para) : public A(para)
{
	...
	C objectFromC;
	objectFromC.methode(this);
}

Wenn die Variable objectFromB in der super-Klasse privat wäre, hätte ich wohl ein Problem, da ich ja auch keinen Getter-Schreiben kann, ohne es auf die abgeleitete Klasse "MainClass" zu beschränken.

In diesem Fall habe ich Glück, es ist public. Aber wie würde man sowas dann noch lösen? (man weiß ja nie, was ich in Zukunft noch machen werde )

kurzer Hinweis:
Ja das mit this ist in diesem Fall, den ich grad mache.
Aber will die Vorwärtsdeklaration machen, weil es auch sein könnte, dass this doch nichts direkt mit A zu tun hat (und in dem Fall wird auch die Methode nicht aufgerufen)

volkard

Schlage Template vor, dadurch kann der Typ verzögert werden.
Und ein wenig SFINAE, damit's wieder eigentlich kein Template ist.

#include <iostream>
using namespace std;

//Datei C.hpp
//Eigener Code, die A.hpp ist nicht inkludiert
template<typename X>
struct IAmReallyAnAB{
};

class C
{
    public:
    template<typename AB>
    typename IAmReallyAnAB<AB>::type methode(AB para)
    {
    }
};

//Datei A.hpp
//Fremder Code, darf nicht angefaßt werden
class A
{
    public:
    class B
    {
    };
};

//Datei meineA.hpp
//#include "A.hpp"
template<>
struct IAmReallyAnAB<A::B>{
    typedef void type;
};

int main()
{
    C c;
    A::B b;
    c.methode(b);//Klappt
    c.methode(1);//Klappt nicht
}

danke für die Antworten
hab mich sehr gefreut