Template Problem

GorbGorb

Hallo,

entschuldigung für den ungenauen Titel, aber ich bin mir nicht sicher ob man das Problem kurz zusammenfassen kann...
Es geht um folgendes: Ich habe eine template class, die ein template member hat. Zu diesem Member würde ich gerne spezialisieren, in etwa so:

template<class X>
class A
{
	template<class Y>
	void func()
	{
	}
	template<>
	void func<X>()
	{
	}
};

Das funktioniert auch mit Visual C++ 2010. Das Problem kommt erst, wenn ich den gcc benutze, weil der sich an den Standard hält, der anscheinend besagt, dass Spezialisierungen von template membern, die in einer template class definiert wurden, sich im diese umgebenden namespace befinden müssen (weiß wer ob das stimmt?).
Meine Versuche waren dann sowas wie:

template<class X>
class A
{
	template<class Y>
	void func();
};
template<> template<class Y>
void A<Y>::func<Y>();

und

template<class X>
class A
{
	template<class Y>
	void func();
};
template<class Y> template<>
void A<Y>::func<Y>();

, was beides nicht funktionierte (auch in vc++ nicht).
Hat wer irgendeine Idee wie bzw. ob ich das compiled bekomme?

Welche gcc-Version hast du denn verwendet?

GorbGorb

Den von der MinGW Version vom 30.05... also nehm ich mal an gcc 4.5.3.

Edit: Ich hab grad noch was zum Thema gefunden:
"An explicit specialization is in the same namespace as the definition of the primary template." (Quelle: IBM C++ Referenz, http://publib.boulder.ibm.com/infocenter/comphelp/v111v131/index.jsp )
Erfüllt also der gcc den Standard hier nicht?

*Q* 1

Ich weiß nciht, ob das das problem ist, aber mir ist aufgefallen, dass du nach den funktionsdefinitionen ein semikolon gesetzt hast.

template<class Y>
void func()
{
};
template<>
void func<X>()
{
};

Mach daraus mal

template<class Y>
void func()
{
}
template<>
void func<X>()
{
}

Edit:
Habs gerade ma getestet, macht nichts aus

GorbGorb

Ja in meinem Anwendungsfall waren das eigentlich Klassen, hab sie dann aber der Einfachheit halber durch Funktionen ersetzt (das ging dann wohl daneben^^)

GorbGorb

Auch wenns vielleicht niemanden mehr interessiert, ich hab die Lösung gefunden:

template< class X >
class TemplateClass
{
private:
    template< class Y , class HelperParam > 
    void functionIntern()
    {
        //unspezialisiert, ohne HelperParam zu verwenden
    }
    template< class Y >
    void functionIntern<Y,Y>()
    {
        //Spezialisierung nur für Y=X (warum, sieht man gleich)
        //Nur explizite Spezialisierungen müssen außerhalb der template class 
        //stehen (hat das eigentlich irgendeinen Grund?).
    ]
public:
    template< class Y >
    void function()
    {
        functionIntern< Y , X >();
        //Spezialisierte Version wird genau dann aufgerufen, wenn beide 
        //Parameter gleich sind, also Y=X
    }
};

Für eventuelle Syntaxfehler garantier ich nicht (hab ich jetzt so neu getippt), aber das Prinzip funktioniert.