sizeof *this object

Question

Code:

#include <cstdio>

class myc {
    int dummy;
public:
    int si(){return sizeof(*this);}
};

class d_myc : public myc {
    int d_dummy;
};

int main() {
    myc a;
    d_myc b;
    printf("%d %d\n%d %d", a.si(), b.si(), sizeof(a), sizeof(b));
    return 0;
}

output :

4 4
4 8

I expected :

4 8
4 8

Why were my expectations wrong?

`class`, etc. are C++ constructs; this code wouldn't compile in C, so this is a C++ question. (And `cstdio` is C++, not C.) — Oliver Charlesworth, Aug 12 '11 at 00:27
I'm a little worried here about what you might be planning to do with the `sizeof` information... — Karl Knechtel, Aug 12 '11 at 00:52
The `sizeof` operator yields a `size_t` result, not an `int`. The `%d` format requires an int argument. For size_t, use `"%zu"` if your system supports it, or use `"%lu"` and cast to `unsigned long`. (Yes, there are systems where it makes a difference.) — Keith Thompson, Aug 12 '11 at 01:15
Im sure my program will give you same results on any (16/32/64 bit)system. — all, Aug 12 '11 at 01:19
If there are virtual pointers and one more class hierarchy your expectations will go wrong again! :) — sarat, Aug 12 '11 at 01:27
@Keith : Or, this being C++, just use `std::cout` and obviate the issue altogether... ;-] — ildjarn, Aug 12 '11 at 02:06
@ildjarn: Yes, of course, I was going to mention that. No, really I was! — Keith Thompson, Aug 12 '11 at 02:10

score 26 · Accepted Answer · answered Aug 12 '11 at 00:26

26

sizeof is resolved at compile-time, not run-time. So sizeof(*this) is equivalent to sizeof(myc).

answered Aug 12 '11 at 00:26

Oliver Charlesworth

267,707
33
569
680

3

And, importantly, acts on the static type of the expression its given, which in this case is `myc`. – ildjarn Aug 12 '11 at 00:27
So if you made si virtual, and copy/pasted it in each class, then it would work correctly? – Aug 12 '11 at 00:29
1

@ildjarn: Even if it were virtual, it wouldn't make a difference. – Oliver Charlesworth Aug 12 '11 at 00:30
@Oli : Yeah, I edited that out seconds after I edited it in. :-P – ildjarn Aug 12 '11 at 00:30
@Oli: what? Sure it does make a difference if it's virtual, because then in `d_myc::si` the static type of `*this` is `d_myc`. – leftaroundabout Aug 12 '11 at 00:46
There are some cases of runtime sizeof, e.g. size of VLA. It make compiler writers a bit mor unhappy. – osgx Aug 12 '11 at 00:46
@leftaroundabout: Sure, yes, if you make the function virtual and then override it. @ildjarn's comment was originally implying that simply making `myc::si` virtual would make a difference. – Oliver Charlesworth Aug 12 '11 at 00:50
@osgx: True. (Although that's C99, not C++.) – Oliver Charlesworth Aug 12 '11 at 00:52
runtime sizeof is GNU extension of C++. I think this is common extension. – osgx Aug 12 '11 at 00:53
2

@osgx: That's entirely possible! But I never investigate such things, because they're non-standard. – Oliver Charlesworth Aug 12 '11 at 00:56

score 1 · Answer 2 · answered Oct 23 '17 at 15:55

This is resolved at compile time:

class myc {
    int dummy;
public:
    int si(){return sizeof(*this);}
};

i.e. *this is always myc and will never be d_myc. To get what you want you will have to override the function in d_myc to do the same in the derived as the base. This is because sizeof(d_myc) includes the base class too.

sizeof *this object

2 Answers2

Linked