Propogating constness through a const member

Below is a compilable (on MS VS 2003) bit of code with a wee little problem.

It does not compile on Comeau because that only permits an anonymous union
to contain a single const member (all const members must be initialised,
only one member of a union can be initialised). Let's ignore that little
problemette.

Somehow I need a different member function of Item being called depending
upon whether it has been accessed via a const or non-const containing
object. Compile time detection would be preferable, but run-time is also
acceptable.

Is there some highly peculiar template malarky that can propogate the
correct constness (without increasing overhead)?

Whoever solves this has effectively enabled zero-overhead properties to
enter the C++ language (payload incurring properties are already doable).

This problem may also be solved by finding some other way to prevent the
default assign-copy operator from being called.

#include <iostream>
struct Data
{ int data[2];
void Init(int a=0,int b=0) { data[0]=a; data[1]=b; }
static Data New(int a=0,int b=0) { Data d; d.Init(a,b); return d; }
};
template <int ITEM>
class Item: private Data
{ Item& Assign(int i) { data[ITEM]=i; return *this; }
public:
operator int() const { return data[ITEM]; }
const Item& operator=(int i) const { const_cast<Item*>(this)->Assign(i);
return *this; }
};
class Twin
{
public:
union
{ Data twin;
const Item<0> d0; // const to prevent default assign-copy being called
const Item<1> d1; // const to prevent default assign-copy being called
};
Twin():twin(Data::New()) { }
Twin(int a,int b):twin(Data::New(a,b)) { }
Twin& operator=(const Twin& t) { twin=t.twin; return *this; }
};
void right(Twin& t)
{ t.d0=0; // Should be permitted given t is non-const
t.d1=0;
}
void wrong(const Twin& t)
{ t.d0=0; // Should NOT be permitted given t is const
t.d1=0; // Can it be solved without adding overhead to Twin?
}
int main()
{ Twin u(123,456),v(7,8);
printf("u.d0=%d, u.d1=%d\n",(int)u.d0,(int)u.d1);
u.d0=v.d0; // u.d1 should be left unaffected
printf("u.d0=%d, u.d1=%d\n",(int)u.d0,(int)u.d1);
wrong(u);
printf("u.d0=%d, u.d1=%d\n",(int)u.d0,(int)u.d1);
printf("sizeof(Twin)=%d, sizeof(Data)=%d\n",sizeof(Twin),sizeof(Data));

return 0;
}

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]