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?

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?

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

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.