objects as template parameters

[kedaman]

struct asdf{int z;};
template <asdf* y>
class c{static const int l;};
template <asdf* y>
const int c<y>::l=y->z;

I wonder how the compiler deals with this? It sure compiles but the templatized class c has to instantiate at compile time, how on earth is it suppose to dereference the asdf pointer :confused:

[CornedBee]

did you try to use this construct? I mean, which address do you supply as template parameter? It must be a constant (like 0xa00000), am I right?

[kedaman]

struct asdf{int z;asdf(int pz):z(pz){};} x(4);

template <asdf* y>
struct c{static const int l;};

template <asdf* y>
const int c<y>::l=y->z;

int main(){

cout << c<&x>::l << endl;
x.z=5;
cout << c<&x>::l << endl;

return 0;
};

It seems like it's done at compile time, at least changing it at runtime won't affect the datatype. I am truly amazed by this :)
BTW can anyone check it out with assembler listings? I don't want to rely that it executes a contructor and why not a whole bunch of functions at compile time if it actually doesnt :eek:

[CornedBee]

My best guess:
the address of a variable is known at compile time. Therefor it can be used to create a real struct out of your template. The created code looks like this:

struct asdf{
int z;
asdf(int pz)
:z(pz)
{};
} x(4);

struct _@3479AD32h_@c { // or whatever temporary name where the template parameter is coded inside
static const int l;
};

// this is copied here, so it doesn't need to change later
const int _@3479AD32h_@c::y = (asdf*)(0x3479AD32)->z;

int main(){

cout << _@3479AD32h_@c::l << endl;
x.z=5; // this has no effect because _@3479AD32h_@c::l is a copy of x.z, not a reference
cout << _@3479AD32h_@c::l << endl;

return 0;
};


(&x = 0x3479AD32)
Is my assumption true?

[kedaman]

Okay :) That gives new life in partial evaluation with templates which didn't work too well in MSVC