local type as template argument

[Filip Konvicka]

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<typena me Y>
struct X : public XC {
X() {
// make this instance globally accessible...
// this runs before main() for each X
// instantiation
global_list.pus h_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<typena me Y>
const char* X<Y>::data=Y::g etYData();

template<typena me YX<YX<Y>::initi alizer;

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>::initializ er exists
X<Y>::initializ er;
}
};
// walk the list of X specializations :
XCL::iterator i, e=global_list.e nd();
for(i=global_li st.begin(); i!=e; ++i)
cout << (*i)->get_data() << endl;
// use X<Ydirectly:
cout << X<Y>::get_data_ static() << endl;
return 0;
}

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2007-05-21 08:30, Filip Konvicka wrote:

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.)

As you said the standard is quite clear on the matter (will hopefully
change in the next standard) so the only trick that I can come up with
is to search the gcc documentation that enables some non-standard
behaviour (just like MSVC8).

--
Erik Wikström

[filip.konvicka]

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.)

As you said the standard is quite clear on the matter (will hopefully
change in the next standard) so the only trick that I can come up with
is to search the gcc documentation that enables some non-standard
behaviour (just like MSVC8).

Thanks for your reply. gcc does not seem to have such feature (I
checked v.4.1.2).

Nevermind, I just wanted to make sure that I did not overlook
something obvious. I'll stick to non-local types then, and wait
eagerly for the next standard (I read some proposals about this, but
it seems to me that it will take years to get into the standard, if
ever).

Cheers,
Filip