Properties revisited

I'm wondering if it is actually possible to work around the 'feature'
whereby a union member can have all manner of methods, assignment and other
operators defined for it, but not the default assignment constructor (nor
default constructor/destructor).

One way is to make the member a reference, but that then takes up storage -
or, if it shares it with the unionised data then the instance's ref is
invalid (the moment the data is adjusted).

Here's an example:

template <class B,int N>
class element: public B
{
     operator int() const { return data[N]; }
     element& operator=(int n) { data[N]=n; return *this; }
};

template <>
class X
{
     union
     { int data[2];
         element<X,0> d0; // First pseudo member of d
         element<X,1> d1; // Second pseudo member of d
     };
};
.....
X x,y;

x.d0=123; // Works fine element<> has operator=(int)
x.d1=456; // Fine
y.d0=7; // Fine
int a=x.d0; // Fine
y.d0=a; // Fine
y.d1=x.d0; // Fine - converts d0 to int

x.d1=y.d1; // BAD! Invokes default assignment operator :-(

I neither want x.d1=y.d1 to do nothing, nor to do default assignment. Either
I want it to be ignored from consideration and a conversion considered
instead, or I want to be able to implement it.

What can I do?

The only solution I've come up with is not really good enough, i.e. prevent
default assignment by making the LHS const:

template <>
class X
{
     union
     { int data[2];
         const element<X,0> d0;
         const element<X,1> d1;
     };
};

By adding const, and constifying the element::operator=(int) with a
const_cast to undo it, I can oblige a conversion rather than a default
assignment.

However, perhaps there is a way that I can pass the constness of X to
element<> such that if X is const the assignment winges at compile time? At
least this preserves constness despite the const being a hack.

Is there a better way?

[Winge]

I can suffer the lack of constructors/destructors - that's fine. But,
prohibiting
non-default assignment, WHY???

By all means, a union can always ignore its members (especially the
secondary ones), and when the encloser is copied the union can be copied bit
for bit according to its size - disregarding any copy constructors or
assignment operators.

But, why not at least allow each secondary member to operate independently
whenever referenced directly?

No reason why I can't also call the constructor with placement new, or the
destructor too. All the union has to do is define secondary members
invisibly coincident (only their size is considered when allocating space
for the union). It can do this for the first member too if preferred.

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