Re: Object layout guarantees and manual pointer adjustments

From:

Francis Glassborow <francis.glassborow@btinternet.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Sat, 18 Apr 2009 16:42:47 CST

Message-ID:

<NLGdnYLyztrbfnTUnZ2dnUVZ8h-dnZ2d@bt.com>

tf@42.sci.utah.edu wrote:

Francis Glassborow <francis.glassborow@btinternet.com> wrote:

Pavel Minaev wrote:

Is the assertion guaranteed to hold? I believe that it does hold for
all existing implementations but I would like to know whether this is
really guaranteed by the C++ standard.

I don't think so. Among other things, C++ standard does not even
guarantee that a non-POD object is allocated as a contiguous block of
memory - so it would seem to be possible for some implementation to
allocate base class subobjects separately (and then the pointer
difference won't hold any meaning, anyway).

The base memory for a complete object must be contiguous. If this was
not the case then it would be impossible to create objects dynamically
with placement new (the version where the programmer provides the memory)

I do not think this is true, but see my comment below; it depends on
what we mean by `contiguous'.

Ref. c++98, 9.2, point 12:

     Nonstatic data members of a (non-union) class declared without
     an intervening access-specifier are allocated so that later
     members have higher addresses within a class object. The
     order of allocation of nonstatic data members separated by an
     access-specifier is unspecified (11.1). Implementation alignment
     requirements might cause two adjacent members not to be allocated
     immediately after each other; so might requirements for space for
     managing virtual functions (10.3) and virtual base classes (10.1).

You might have meant that the whole object is contiguous, if one
includes the additional spacing which a compiler is allowed to insert
(that is, it depends what we mean by `contiguous'). I think but have
not verified that this is true. Given the OPs question though, I'm not
sure that such a guarantee, true or not, would be useful.

Cheers,

When saying that a complete object must occupy contiguous bytes
(remember I am referring to base memory not to memory held through
pointers) I have not said, nor would I say that there can be no padding.
However padding is part of the object. It is even possible for padding
in a base sub-object can be recycled for use in a derived object. E.g.
(AFAIK):

struct base {
    char c;
    int i;
};

struct derived: public base {
    char c1;
};

can have the sizeof both base and derived the same because on a system
where alignment considerations result in padding between c and i can use
some of that padding for c1.

I cannot imagine how a system might work where the value of sizeof(T)
was the result of summing two or more non-contiguous chunks of storage.

I think the following code must always work for all types T (given
enough memory is available)

int main(){
    void* mem_ptr = operator new( sizeof(T));
    T* T_obj = new (mem_ptr) T;
}

Now explain, if you can, how that could work if the base memory for T
could be non-contiguous.

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