Mark P wrote:
A colleague asked me something along the lines of the following today.
For some type X he has:
X* px = new X[sz];
Then he wants to convert px to a char* (I'm guessing for the purpose of
serializing the object array).
What for? Why not provide your own operator<< and operator>> for type X?
Lets consider what happens if type X is composed of primitive types,
containers, pointers and references.
Doesn't it make sense that its a better solution to stream those
componants rather than carying out a byte-by-byte transfer of the
object? What if the target of the transfer uses a different architecture
(or a different compiler). Why would you want to have to deal with the
type's padding?
The proposed solution above and below therefore constitute a good
example of undefined behaviour. Not to mention unneccesary bits being
transferred and having to detect the source and target architectures as
well as writing a new function to handle each possibility.
Why do it the hard way with undefined results when writing a simple
operator rids you of all the headaches?
std::ostream& operator<<(std: :ostream& os, const X& x)
{
// stream the relevent componants into os
// return os;
}
and make the above function a friend of type X.
It doesn't get any simpler. And its portable.
I can think of three ways to do this:
char* pc = (char*) px;
char* pc = static_cast<cha r*> (static_cast<vo id*> (px));
char* pc = reinterpret_cas t<char*> (px);
From my reading of the standard it seems that the results of these
casts are all unspecified.
I don't see a cast, i see a non-portable hack. The above is in fact
guarenteed to fail. Don't casting unless you develop a healthy respect
for what they do.
Is this true?
In practice, would these casts ever do anything besides the obvious?
Is there any portable way to access the bytes of an object's
representation?
Of course there is. The key is to access the *relevent* bytes. What is
relevent can very well depend on the requirements and needs.
You are assuming than an object will occupy in memory the sum of the
allocations of its componants. If your computer did not rely on
segment+index addressing schemes it would slow to a crawl. In C++ its
critical to provide code that is transparent to the platform its running
on. Your code needs to stream the object's components with no regards to
the architecture/platform underneath. Thats what C++ is all about.
Lets slap together a dumb example.
#include <iostream>
#include <ostream>
class X
{
char c;
int n;
public:
X() : c(' '), n(0) { }
~X() { }
};
int main()
{
X x;
std::cout << "sizeof(x) = " << sizeof(x) << std::endl;
}
/*
sizeof(x) = 8
*/
Interestingly enough on my system a char is 1 byte and an integer is 4
bytes (your mileage may well vary). So why the size of 8 bytes? Answer:
padding. Why would you ever want to pay an 8 byte transfer when you can
simply stream the char and integer? No hacking required. With a portable
result too.
Lets prove it, how about streaming type X objects to your standard
output? After all, it uses a std::ostream too, doesn't it? You can
replace std::cout with any interface that can accept a standard output
stream. All you need is a simple operator<< to stream your precious type
in any fashion you desire.
#include <iostream>
#include <ostream>
class X
{
char c;
int n;
public:
X() : c(' '), n(0) { } // default ctor
X(char c_, int n_) : c(c_), n(n_) { }
~X() { }
/* friend operator<< */
friend std::ostream& operator<<(std: :ostream& os, const X& r_x)
{
os << "c = " << r_x.c; // stream the char
os << "; n = " << r_x.n; // stream the integer
return os << std::endl;
}
};
int main()
{
X xa('a', 0);
X xb('b', 1);
std::cout << "xa: " << xa;
std::cout << "xb: " << xb;
}
/*
xa: c = a; n = 0
xb: c = b; n = 1
*/
Are you now seeing the simplicity and power in the design? What if the
private member integer was in fact another class? No problem, write an
op<< for it too. What if i needed a container of 1000 X elements? What
if you needed to stream the whole container of 1000 X elements to
standard output?
Your way you would need hundreds of lines of code. And it would still
not be portable. I can create, load and stream a container of 1000 X
elements in 3 lines of code excluding includes. Yes: 3. Completely
portable and reusable.
hint: std::vector< X > vn(1000); // and std::copy(...) to std::cout
