Re: [boost] dangerous_cast<>

From: Anthony Williams (anthony.williamsNOSPAM_at_[hidden])
Date: 2002-12-05 05:05:01

Gabriel Dos Reis writes:
 > "Peter Dimov" <pdimov_at_[hidden]> writes:
 > 
 > | From: "Gabriel Dos Reis" <gdr_at_[hidden]>
 > | > David Abrahams <dave_at_[hidden]> writes:
 > | >
 > | > | Gabriel Dos Reis <gdr_at_[hidden]> writes:
 > | > |
 > | > | > Hmm, I have a couple of questions answers to which will help me
 > | > | > get your point.
 > | > | >
 > | > | >  1) Why can't you do that with reinterpret_cast?
 > | > |
 > | > | You can, but the results are non-portable
 > | >
 > | > No more non-portable than with dangerous_cast<>.
 > | 
 > | I think that Dave's point is that in
 > | 
 > | new(h.storage) Foo;
 > | 
 > | there is a char* -> void* implicit conversion as placement new takes a
 > | void*. So the placement new performs char* -> void* -> Foo* (by constructing
 > | a Foo at (void*)h.storage), which - in theory - might not be the same as
 > | char* -> Foo*.
 > 
 > But then, that theoretical implementation can remember the type from
 > which the conversion to void* was made and may issue an error when an
 > attempt is made to dereference the pointer obtained by recasting the
 > result of static_cast<void*>(h.storage) to Foo*.
 > 
 > Practical notes:
 > Historically, char* was used as the type of "raw memory" until "void*"
 > was invented.  And since then char* and void* continues to have the
 > same properties as raw-memory issues are concerned.

unsigned char* has _additional_ properties to void* --- you can access the
object representation of _any_ object through an unsigned char* (and for PODs,
you can copy them around using this)

3.9p4:
  "The object representation of an object of type T is the sequence of N
  unsigned char objects taken up by the object of type T, where N equals
  sizeof(T)."

3.10p15:
  "If a program attempts to access the stored value of an object through an
  lvalue of other than one of the following types the behavior is undefined:

  - the dynamic type of the object,

  ...

  - a char or unsigned char type."

So given a Foo object foo, static_cast<char*>(static_cast<void*>(&foo)) is
legal, and can be used to access the object representation of the object.

Also, 3.9.2p4 says: 
  "Objects of cvqualified (3.9.3) or cvunqualified type void* (pointer to
  void), can be used to point to objects of unknown type. A void* shall be
  able to hold any object pointer. A cvqualified or cvunqualified (3.9.3)
  void* shall have the same representation and alignment requirements as a
  cvqualified or cvunqualified char*."

So casting a void* to/from a char* is a no-op.

3.8p1:
  "The lifetime of an object is a runtime property of the object. The lifetime
  of an object of type T begins when:

  - storage with the proper alignment and size for type T is obtained, and

  - if T is a class type with a nontrivial constructor (12.1), the constructor
  call has completed."

Thus, given that h.storage is properly aligned, (which is the purpose of the
other union member), after "new(h.storage) Foo", h.storage contains a Foo
object. Thus accessing it through a pointer-to-Foo is legal, as Foo is the
dynamic type of the object.

The question is: is the Foo* returned by the placement new expression (which
is usable) the same as the Foo* returned from
static_cast<Foo*>(static_cast<void*>(h.storage))?

The object representation of the Foo object is the sizeof(T) bytes starting at
static_cast<void*>(h.storage) (since that is what was passed to placement
new), so static_cast<void*>(pfoo)==static_cast<void*>(h.storage) if pfoo is
the value returned from the new expression.

Thus

static_cast<Foo*>(static_cast<void*>(pfoo))
==static_cast<Foo*>(static_cast<void*>(h.storage))
==pfoo

and we're legal.

Anthony
-- 
Anthony Williams
Senior Software Engineer, Beran Instruments Ltd.
Remove NOSPAM when replying, for timely response.