C++Talk.NET

Filip Konvicka · Guest

Hi 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++ (3.4.3, did not try newer). I was essentialy able to run
some code for each local type before main() - see the source code below.

I know that to make it work, one could simply make the class non-local,
but I'd like to keep the classes local and achieve some pre-main
initialization for them. I know that the standard is clear about this,
but maybe there is some trick...? The reason for all this is my desire
to see all locally-defined strings (so I can do localization etc.)

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

Guest