local type as template argument

Hello all,

I wonder whether anyone has seen a workaround for this somewhere,
perhaps in Boost or elsewhere...

I succeeded using a local type as template argument in MSVC 8.0, but I
found out that this violates the standard (14.3.1.2), and sadly does not
work with g++. I was essentialy able to run some code for each local
type before main() - see the source code below.

Thanks for suggestions,
Filip

#include <iostream>
#include <list>
using namespace std;

// common interface
struct XC {
   virtual const char* get_data() = 0;
   virtual ~XC() {}
};
typedef list<XC*> XCL;
XCL global_list;

template<typename Y>
struct X : public XC {
   X() {
     // make this instance globally accessible...
     // this runs before main() for each X
     // instantiation
     global_list.push_back(this);
   }
   virtual const char* get_data() {
     return get_data_static();
   }
   static X initializer;
   // return data associated with Y
   static const char* get_data_static() {
     return data;
   }
   // data associated with Y
   static const char* data;
};

template<typename Y>
const char* X<Y>::data=Y::getYData();

template<typename Y> X<Y> X<Y>::initializer;

int main(int argc,char* argv[]) {
   // the local type whose data
   // will be visible globally
   struct Y {
     static const char* getYData() {
       return "some data";
       // make sure X<Y>::initializer exists
       X<Y>::initializer;
     }
   };
   // walk the list of X specializations:
   XCL::iterator i, e=global_list.end();
   for(i=global_list.begin(); i!=e; ++i)
     cout << (*i)->get_data() << endl;
   // use X<Y> directly:
   cout << X<Y>::get_data_static() << endl;
   return 0;
}