Classes Templates imbriquées

Bonjour,

J'essaye de déclarer une classe "Exception" imbriquée à l'intérieur
d'une classe template "Foo", et j'ai quelques problèmes de compilation,
j'ai recréé un petit programme d'exemple pour essayer d'isoler le
problème, mais je ne suis arrivé à le résoudre jusqu'à présent, et
google ne m'a pas donné grand chose. J'ai mis les sources du programme à
la fin du mail.
Ma classe exception dérive std::exception, et je voudrais qu'elle garde
une copie de l'objet qui a provoqué l'exception, pour afficher des infos
dessus. Le problème c'est que l'objet en question étant un template,
cela implique a priori que ma classe imbriquée soit aussi un template.
Donc en gros j'ai une classe Foo<NUMBER> où est déclarée
Exception<NUMBER2>.
J'aimerai définir le corps de ma fonction hors du fichier d'en tête, et
demander explicitement l'instanciation de cette classe pour quelques
types. Mon problème concerne justement la syntaxe de définition des
fonctions de cette classe imbriquée.
J'ai trouvé un site qui parlait vaguement de la syntaxe de définition
des membres imbriqués dans une classe template:
http://www.comeaucomputing.com/techtalk/templates/
il est dit:
<quote>
If you have a nested member template within a template:

template <typename T>
struct xyz {
// ...
template <typename U>
struct abc;
// ...
};

[...]

You would have to do this:

template <typename T>
template <typename U>
struct xyz<T>::abc {
// ...
};
</quote>

J'ai utilisé cette syntaxe (et tenté plein d'autres), or le problème,
c'est qu'aucune ne semble reconnue par le compilateur (VC++ 7.0).
Est ce que quelqu'un pourrait m'éclairer sur comment faire marcher ce
prog ?

Merci d'avance !

Fred

Sources:
// Fichier Foo.h

#include <exception>
#include <string>
#include <sstream>

using namespace std ;

template<class NUMBER> class Foo ;

template<class NUMBER>
class Foo
{
public:
template<class NUMBER2>
class Exception : public std::exception
{
public:
Exception( string msg, Foo<NUMBER2> obj ) throw() ;
const char *what() const throw() ;
private:
string userErrorMsg, fullErrorMsg ;
Foo<NUMBER2> errorObject ;
} ;

Foo( string name ) ;
void DoStuff( NUMBER x ) ;

friend ostream& operator<<( ostream& stream, const Foo<NUMBER>& obj ) ;

protected:
string objectName ;
};



// Fichier Foo.cpp

#include "foo.h"
#include <iostream>

// ***************************************
// La le compilo aime pas du tout:
// error C2988: impossible de reconnaître la définition/déclaration de
modèle
// error C2059: erreur de syntaxe : ''template<''
// error C2955: 'Foo<NUMBER>::Exception' : l'utilisation d'un modèle de
classe nécessite une liste d'arguments de modèle
// *************************************
template<class NUMBER> template<class NUMBER2>
Foo<NUMBER>::Exception::Exception( string msg, Foo<NUMBER> obj )
throw()
: userErrorMsg( msg ), errorObject( obj )
{
}

template<class NUMBER> template<class NUMBER2>
const char *Foo<NUMBER>::Exception::what() const throw()
{
ostringstream oss ;
oss << "problem with objet: " << errorObject << endl
<< objecterrorMsg << endl ;
fullErrorMsg = oss.str() ;
return fullErrorMsg.c_str() ;
}


template<class NUMBER>
Foo<NUMBER>::Foo( string name )
: objectName( name )
{
}

template<class NUMBER>
void Foo<NUMBER>::DoStuff( NUMBER x )
{
if( x < 0 )
{
throw Exception<NUMBER>( "Error", *this ) ;
}
cout << "Hello" << endl ;
}

template<class NUMBER>
ostream& operator<<( ostream& stream, const Foo<NUMBER>& obj )
{
return stream << ' ' << obj.objectName ;
}

template Foo<double> ;
template ostream& operator<<( ostream& stream, const Foo<double>& obj ) ;



// Main.cpp

#include "Foo.h"
#include <iostream>

int main(void)
{
try
{
Foo<double> bar( "Test object" ) ;

bar.DoStuff( -1.0 ) ;
cout << bar << endl ;
}
catch( const exception& e )
{
cerr << e.what() << endl ;
}
}