Re: Anonymous union rules against constructors & assignment

<johnchx2@yahoo.com> wrote in message
news:1149696094.781890.80420@f6g2000cwb.googlegroups.com...


OOOPS. Sorry. Insufficiently accurate recall of the hack. Many apologies!

This should be a compilable version of the hack.

#include <iostream>
struct Apple
{
int a,b;
};
class A: public Apple
{
A& CustomAssignCopy(int i) { a=i; return *this; }
public:
operator int() const { return a; }
A& operator=(int i) const { return
const_cast<A*>(this)->CustomAssignCopy(i); }
};
class B: public Apple
{
B& CustomAssignCopy(int i) { b=i; return *this; }
public:
operator int() const { return b; }
B& operator=(int i) const { return
const_cast<B*>(this)->CustomAssignCopy(i); }
};

class UA
{
public:
union
{ Apple apple;
const A a; // const to prevent default assign-copy being called
const B b; // const to prevent default assign-copy being called
};
UA() { apple.a=0; apple.b=0; }
UA(int a,int b) { apple.a=a; apple.b=b; }
UA& operator=(const UA& ua) { apple=ua.apple; return *this; }
};
int _tmain(int argc, _TCHAR* argv[])
{ UA u(123,456),v(7,8);
// u=v;
printf("u.a=%d,u.b=%d\n",(int)u.a,(int)u.b);
u.a=v.a;
printf("u.a=%d,u.b=%d\n",(int)u.a,(int)u.b);
printf("sizeof(UA)=%d, sizeof(Apple)=%d\n",sizeof(UA),sizeof(Apple));

return 0;
}

By making the union member const, the default assignment-copy operator is
never selected because it requires a non-const lvalue, therefore my
assignment from int is selected because it can work with a const
lvalue.

If it wasn't const, the default assign copy operator would have been called
which would copy a AND b - even though that's not what I want, and I'm not
allowed to override it.

NOW I can get all indignant! :)

And I'm led to believe the above code is perfectly safe UNTIL A or B is
permitted to have a non-default assign-copy operator.


Sure, look for the anonymous union below and the members I'm having to make
const in order to prevent the default assign-copy operator being called
(which some nanny has decided that I shouldn't be permitted to override
because I might hurt myself).

[REPOSTING less code - I suspect may have been rejected by moderators due to
too much contextual code]

template <class VECTOR_REPRESENTATION, bool IS_ROW, class
VECTOR_TRAITS=vector_traits<VECTOR_REPRESENTATION> >
class vector_base: protected VECTOR_TRAITS // General homogenous 3D vector
{
public:
 explicit vector_base(const VECTOR_REPRESENTATION& v):representation(v) { }
public:

// explicit vector_base(const VECTOR_TRANSPOSE& v):representation(v) { }

// static vector_base construct(const VECTOR_REPRESENTATION& v) { return
v; }

 typedef typename VECTOR_TRAITS::vector_representation
vector_representation;

 typedef typename VECTOR_TRAITS::precision precision; // Used for internal
passing
 typedef typename VECTOR_TRAITS::scalar scalar; // Used for external
arguments

 enum { default_is_row=VECTOR_TRAITS::default_is_row,
default_is_column=VECTOR_TRAITS::default_is_column };

 typedef typename VECTOR_TRAITS::vector_default vector_default;
 typedef typename VECTOR_TRAITS::normal_default normal_default;

 typedef typename VECTOR_TRAITS::vector_row vector_row;
 typedef typename VECTOR_TRAITS::vector_column vector_column;

 enum { is_row=IS_ROW,is_column=!IS_ROW,is_vector=(IS_ROW==default_is_row),
is_normal=(IS_ROW==default_is_column) };

 typedef typename vector_base<VECTOR_REPRESENTATION,IS_ROW,VECTOR_TRAITS>
vector_this;
 typedef typename vector_base<VECTOR_REPRESENTATION,!IS_ROW,VECTOR_TRAITS>
vector_transpose;

public:
 union
 { VECTOR_REPRESENTATION representation;
// CONVENIENT PROPERTIES - read & write
  const vector_property<property_indexed_element<vector_representation,0> >
x;
  const vector_property<property_indexed_element<vector_representation,1> >
y;
  const vector_property<property_indexed_element<vector_representation,2> >
z;
  const vector_property<property_indexed_element<vector_representation,3> >
w;

  vector_property<property_cast<vector_representation,vector_transpose> > t;
// Tranpose
  vector_property<property_cast<vector_representation,normal_default> > n;
// As a normal
  vector_property<property_cast<vector_representation,vector_default> > v;
// As a vector
  vector_property<property_cast<vector_representation,vector_row> > r; //
As a row vector
  vector_property<property_cast<vector_representation,vector_column> > c;
// As a column vector

  const vector_property<property_magnitude<vector_representation> > m; //
Magnitude
  const vector_property<property_magnitude_squared<vector_representation> >
s; // Magnitude squared

  const
vector_property<property_direction<vector_representation,vector_this> > d;
// Direction (returns this normalised, or assigns a new direction without
affecting magnitude)

  const vector_property<property_alpha<vector_representation> > a; // Polar
rotation about z
  const vector_property<property_beta<vector_representation> > b; // Polar
elevation into z
 };

// Constructors

 vector_base() { } // Potentially controversial non-initialisation
 vector_base(const vector_base& v) { representation.assign(v); }
 vector_base& operator=(const vector_base& v) { representation.assign(v);
return *this; }
 vector_base(double dx,double dy,double dz,double dw=0.0)
 { representation.initialise((scalar)dx,(scalar)dy,(scalar)dz,(scalar)dw);
 }

 static vector_base polar(scalar alpha,scalar beta,scalar magnitude,scalar
dw=0.0)
 { // todo
 }

// Conversions
 operator bool() const { return !representation.is_null(); }
 operator const VECTOR_REPRESENTATION&() const { return representation; }
// operator unit_vector() const;// Convert
 //operator unit_normal() const; // Convert

// Functions

 bool operator!() const { return representation.is_null(); }

 vector_base operator~() const { return representation.direction(); } //
Returns the direction of the position vector or unit vector if w=0
 vector_base operator-() const { return representation.negation(); }

// Assignments

// Modifications

 vector_base& operator*=(scalar s) { representation.scale(s); return
*this; }
 vector_base& operator/=(scalar s) { representation.scale(scalar(1)/s);
return *this; }

 vector_base& operator+=(const vector_base& v) { representation.add(v);
return *this; }
 vector_base& operator-=(const vector_base& v) { representation.subtract(v);
return *this; }

};

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]