Re: Sizeof struct containing T?
On Sep 13, 1:59 am, Daniel Kr?gler <daniel.krueg...@googlemail.com>
wrote:
On 11 Sep., 12:22, Jiang <goo.mai...@yahoo.com> wrote:
On Sep 11, 12:32 am, Martin Bonner <martinfro...@yahoo.co.uk> wrote:
sizeof(U) >= sizeof(T), but it reallistically is possible for
sizeof(U) > sizeof(T).
If T can be any type then it is possible that sizeof(U)
will be even smaller than sizeof(T).
No, that is impossible, v.i.
I am not sure whether I explained my point clearly or not,
I will do it again.
#include <iostream>
struct t
{
char a[32];
};
typedef t& T;
OK, T is a reference type, but this is *not* the same as T.
Quite true. Isn't it?
But here I meant the T *is* a reference type, and the
type be referenced , say struct t, is not really important.
struct U
{
T b; // ignore its initialization ...
};
U contains now a *reference* to a t.
Yes, that's the point.
If a class U holds a reference type T as its member,
then sizeof(U) can not report the actual size of
the object referenced by T.
Note also, that it is
impossible to omit the initialisation of a variable of reference type.
True.
I removed the constructor to make layout of U similar as OP.
However, IMHO, add the constructor back won't break my above
words, well, if we stay in a more general context.
int main()
{
std::cout << "sizeof(T):" << sizeof(T) << std::endl;
std::cout << "sizeof(U):" << sizeof(U) << std::endl;
}
$ ./aout
sizeof(T):32
sizeof(U):4
This is expected and does not disprove Martin's assertion.
So what is Martin's assertion?
Actually in my previous post I was not quite sure
about that and I added the precondition for my
words. That is, here the member T can be any type.
There exists a special rule in C++ for sizeof in namely [expr.sizeof]/2 :
"When applied to a reference or a reference type, the result is the size
of the referenced type[..]"
Yes, a good, old, solid rule from the very beginning...
But as I explained just now, for a type U that contains a reference
member, nowhere in the standard says the size of the referenced
type will be counted and added to the sizeof(U) .
which effectively guarantees:
static_assert(sizeof(X) == sizeof(X&), "sizeof is immune to
references");
Here I failed to see your point.
You are comparing sizeof(X) with sizeof(X&), and in my
previous post, I compared sizeof(T) with sizeof(U), where
T is a member of U.
It's not specified by the standard, but typical implementations will use
an X* to implement X& as data member of a class, which nicely explains
the outcome of sizeof(U).
The 4 bytes output of sizeof(U) does not surprise me at all.
I added the output log just for saving compile&test time for
others.
Here,
1. If we want to simulate reference using pointer, we
should use " const X * " .
2. Since reference itself is not an object, the standard
even does not guarantee storage for reference.
3. The actual sizeof(U) is not an issue here.
BTW, as I said many times in this group, using sizeof()
for non-PODs is just asking for trouble. My previous
example was intended to prove it.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]