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

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.

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

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

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?

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 )

#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
}