Re: Does C++ standard require objects to be allocated in continuous
memory?
* Victor Bazarov:
Andrew Koenig wrote:
"Victor Bazarov" <v.Abazarov@comAcast.net> wrote in message
news:g7s5ks$bgt$1@news.datemas.de...
Yes, it requires that objects occupy a contiguous memory portion.
That's how an object is defined.
Not quite. Consider:
struct A { int a; };
struct B: virtual A { int b; };
struct C: virtual A { int c; };
struct D: virtual A { int d; };
struct E: B, C, D { };
Every object of type E includes objects of types B, C, and D among its
base-class parts. Those objects, in turn, share a common sub-object
of type A. Therefore, if we have an object of type E, at least one of
the B, C, or D objects must occupy noncontiguous memory.
Since E::B is not the same as B, most likely we're talking about
stand-along objects, not subobjects of other object, then? Of course,
the OP didn't specify what he was asking about.
I think the OP was asking about something that does not exist,
<q>
For a class containing variables and constant values one might want to put
the variables in RAM and the constants in ROM, which means that the object
is split into different parts in memory.
</q>
If there is a compile constant (static const) then it's part of the class but
not of any instance of the class.
Apart from that, I remember me and Dave Abrahams having a little flame war (in
clc++m) over the issue that Andrew Koenig raises here. At least I think it was
Dave. And Dave's position then, IIRC, was that even for a complete object, if it
was non-POD then the standard allowed the parts to be scattered hither and
dither in memory, that a "region of storage" was not necessarily contiguous
(which of course it isn't with virtual inheritance in the picture). But I
suspect that was not a position he'd argued so strongly for if it had started
with that. Instead, we were sort of forced, by our own arguments, into
diametrically opposite positions, going a little bit to extremes. :-)
As a matter of practice I teach to others that a complete C++ object occupies a
contiguous chunk of memory (of course an object may contain pointers introduced
by the programmer, that's not the issue here). If that's technically wrong I
don't think it does any harm. On the contrary, I think it's a good way to
understand practical C++, like not being overly concerned about ice-bears
falling from the sky into one's head even if that's theoretically possible: it's
safe to walk outdoors, in general, and it's safe to assume that contigousness.
Yet I've always wondered if Dave was technically right, because at the start,
one main argument was that even if the standard didn't say so, this possible
non-contigousness for complete objects was the committee's *intention*, that it
went to extraordinary lengths to ensure that it would be possible, and I can't
for the life of me figure out what it then was intended to support.
Cheers,
- Alf
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?