Re: Reference to this
Uzytkownik "Bob Hairgrove" <invalid@bigfoot.com> napisal w wiadomosci
news:8emr53l9ahfqf0omp1t7ir3boiailsvqsv@4ax.com...
{ Edits: double-spacing removed. -mod }
On Wed, 30 May 2007 14:42:22 CST, Craig Scott
<audiofanatic@gmail.com> wrote:
There are perhaps some better parts of the standard for clarifying
this, but a quick check yielded the following for 12.7/2:
"...To form a pointer to (or access the value of) a direct nonstatic
member of an object obj, the construction of obj shall have started
and its destruction shall not have completed, otherwise the
computation of the pointer value (or accessing the member value)
results in undefined behavior."
In other words, as long as the constructor has started, you can take
the address of or a reference to any of its non-static members (NB:
you cannot dereference that pointer or use the reference though until
the member itself has been constructed). There are also examples in
12.7/2 and 12.7/3 where the "this" pointer is used as an argument to
base class constructors.
Am I correct in the assumtion that the phrase "[...] the construction
of obj shall have started [...]" means that the initialization list
has been entered, and that we don't have to wait until the body of
the constructor has been entered? It would make sense, because the
compiler really needs to know about the addresses of the members of
the current type in the initialization list and cannot restrict
itself only to the members of the base class(es).
If that is so, then the warning that one popular compiler issues when
passing "this" to the constructor of some member or base class is
spurious at best.
The compiler does not know what you use this pointer for.
If you store it for using at a later time, there is no harm;
if you want to access the object in any way, it is asking for trouble.
Thus there are situations where it is not spurious at all.
Actually, since this is a hot topic for me, I would like to add another
remark.
Storing a this in a member allows to simulate virtual inheritance:
when you ask for any interface (IUnknown), you get it from the object,
not from the member.
However, my problem is
this is suboptimal in the typical situation
where the implementation objects are members of the host object stored
at offsets known at compile time;
thus,
the value reinterpret_cast<unsigned char const *>(this) -
reinterpret_cast<unsigned char const *>(host)
is constant and depends only on the compiler used.
Getting the host pointer from the interface pointer is covered my the
dynamic_cast operator in C++;
however, dynamic_cast + virtual inheritance = the same memory overhead,
only behind the scenes,
because the implementations of the interface can be laid out in any order.
What is needed is a class cannot be used to instantiate a stand-alone
object,
only a particular member of a particular class
so that you can get the address of the host object by adjusting the
pointer to the member object
with a constant negative value.
AFAIK, there is no way to get this effect in today's C++,
except that, ironically, when you fall back to C, you can use offsetof
for that purpose.
ATL does use offsetof with class objects, but it is nonstandard.
Would it make a good topic for comp.std.c++?
I shall be grateful for your thoughts
Chris
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]