Re: Anonymous union rules against constructors & assignment
johnchx2@yahoo.com wrote:
"Crosbie Fitch" wrote:
Yes it would get the right behaviour, but not the right payload. Your refs
add overhead.
Let's pretend we have a vast volume of legacy code with a class that exposed
public data members, and yet we need to change the behaviour of the class
without either changing its size or shape. Let's say it's a struct with two
floats, and they can't be touched, but we need to intercept them being read
or written. We could make the floats private, and expose the two original
member variable names as proxy objects exposed as empty members within an
anonymous union also containing the floats. We can trap all operations on
those members EXCEPT assign-copy. We can trap assign from float (c.x=1.f),
and cast to float (f=c.x), and assign from different member (c.x=d.y), but
not assign member from same member (c.x=d.x).
So the feature you actually need is zero-size reference members, and
the only reason unions got into the mix was that you thought you could
use them to emulate the desired feature.
C++ already supports zero-sized data members - they are called member
functions. A C++ member function is much more than a notational
convenience for programmers. Instead, member functions - along with
constructors, destructors and operator overloads - comprise C++'s type
system. And it is this type system that makes writing a program in C++
a fundamentally different experience than writing a program in C.
Whereas a C programmer may have little choice but to use a union as C
defines it in order to solve a particular problem - a C++ programmer in
the same situation has an additional option: that is, not to use the
built-in union type but to write a replacement. In other words, the
completeness of C++ type's type system does not at all handicap the C++
programmer - but in fact it has completely the opposite effect. The
relative completeness of C++'s user-defined, extensible type system is
empowering: it frees the programmer from reliance on built-in types and
their behaviors - or to put it another way: the C++ programmer can
effectively extend the language itself in order to solve problems.
And it is not too difficult to see how the C++'s type system could
implement a union-like replacement. Simply chnage the d0 and d1
instance variables in the example program into class methods; aside
from some minor adjustment to syntax, the client code remains
unchanged. The implementation of the union-like class itself though
improves significantly (by eliminating the union, the data member
const-ness, and the helper class template):
#include <cstdio>
using std::printf;
struct Data
{
int data[2];
Data(int a=0, int b=0)
{
data[0] = a;
data[1] = b;
}
};
class Twin
{
private:
Data twin;
public:
Twin() {}
Twin(int a, int b)
: twin( Data(a, b)) {}
Twin& operator=(const Twin& t)
{
twin = t.twin;
return *this;
}
int& d0() { return twin.data[0]; }
int d0() const { return twin.data[0]; }
int& d1() { return twin.data[1]; }
int d1() const { return twin.data[1]; }
};
int main()
{
Twin u(123,456), v(7,8);
printf("u.d0() = %d, u.d1() = %d\n", u.d0(), u.d1());
u.d0() = v.d0(); // u.d1() should be left unaffected
printf("u.d0() = %d, u.d1() = %d\n", u.d0(), u.d1());
printf("sizeof(Twin) = %d, ", sizeof(Twin));
printf("sizeof(Data) = %d\n", sizeof(Data));
}
Program Output:
u.d0() = 123, u.d1() = 456
u.d0() = 7, u.d1() = 456
sizeof(Twin) = 8, sizeof(Data) = 8
Greg
---
[ 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 ]