Question

here is code which returns size of struct without using sizeof keyword

#include <iostream>
using namespace std;
struct  point{
    int x;
    int y;
    };
struct point pt={0,0};

int main(){
    point *ppt=&pt;
    unsigned char *p1,*p2;
    p1=(unsigned char *)ppt;
    p2=(unsigned char *)++ppt;
    printf("%d",p2-p1);


     return 0;
}

it returns 8 as i understand because sizeof char is 1 byte and this struct contains integer types first it convers it to char using char pointers and returns sizeof char? or?i dont understand exactly how it works
thanks

Answer 1

The cast here happens after the ++

p2 = (unsigned char *)++ppt;

It works because ++ on a pointer increases the pointer the number of bytes equal to the size of the type pointed to. Then you cast to char, because minus divides the difference in pointers by the size of the type (so divide by 1 because it’s now char*).

One caveat if you plan to use this — sizeof is definitely done at compile time where this code may or may not be recognized by the optimizer as being a constant expression.

Also, as pointed out by the commenter and other question, it won’t match sizeof if the type needs alignment (some systems require that types start on memory boundaries divisible by 2, 4, etc).

Finally, (from the comments), once the pointer has been incremented, it is invalid and cannot be used (even for subtracting, comparison — i.e. even in ways that don’t dereference it)

From the C Rationale Document: http://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf

Implicit in the Standard is the notion
of invalid pointers. In discussing
pointers, the Standard typically
refers to “a pointer to an object” or
“a pointer to a function” or “a null
pointer.” A special case in address
arithmetic allows for a pointer to
just past the end of an array. Any
other pointer is invalid.

An invalid pointer might be created in
several ways. An arbitrary value can
be assigned (via a cast) to a pointer
variable. (This could even create a
valid pointer, depending on the
value.) A pointer to an object becomes
invalid if the memory containing the
object is deallocated or moved by
realloc. Pointer arithmetic can
produce pointers outside the range of
an array.

Regardless how an invalid pointer is
created, any use of it yields
undefined behavior. Even assignment,
comparison with a null pointer
constant, or comparison with itself,
might on some systems result in an
exception.

Consider a hypothetical segmented
architecture on which pointers
comprise a segment descriptor and an
offset. Suppose that segments are
relatively small so that large arrays
are allocated in multiple segments.
While the segments are valid
(allocated, mapped to real memory),
the hardware, operating system, or C
implementation can make these multiple
segments behave like a single object:
pointer arithmetic and relational
operators use the defined mapping to
impose the proper order on the
elements of the array. Once the memory
is deallocated, the mapping is no
longer guaranteed to exist. Use of the
segment descriptor might now cause an
exception, or the hardware addressing
logic might return meaningless data.