不使用sizeof查找尺寸

Question

I understand that we can find the size of a pointer of certain type using the following:

printf("size of an int pointer: %d", sizeof(int*));
printf("size of a float pointer: %d", sizeof(float*));
printf("size of pointer to void: %d", sizeof(void*));

In C, is it possible to find the size of a struct without needing to use sizeof ?

Answer 1

Perform pointer arithmetic and measure the step size.

#include <stdio.h>
struct foo { char a[5],b[98];};

#define SYZEOV(t) ((size_t)((void*)(((t*)(NULL))+1)-NULL))


int main(int m, char**n){
  printf("sizeexpr=%ld\n", (long)((void*)(((struct foo*)(NULL))+1)-NULL));
  printf("syzeov  =%ld\n", (long)SYZEOV(struct foo));
  printf("sizeof  =%ld\n", (long)sizeof(struct foo));
  return 0;
};

Answer 2

Yes, we could do the following to find the size of a struct without using sizeof :

struct myStruct
{
   int a;
   int b;
}

struct myStruct s = {0, 0};

myStruct *structPointer = &s;
unsigned char *pointer1, *pointer2;
pointer1 = (unsigned char*) structPointer;
pointer2 = (unsigned char*) ++structPointer;

printf("%d", pointer2 - pointer1);

Answer 3

In short, you can't. Some people have suggested using pointer arithmetic, like you did in your answer, as well as using macros to make "a sizeof operator." The reason being that sizes of data types are only known by the machine's compiler. Your pointer arithmetic is using the sizeof operator, "behind the scenes".

Answer 4

C is designed in such a way that sizeof always returns the amount of pointer increment in bytes to move to the next array element, so that sizeof(type[N]) == N*sizeof(type) is always true.

Then it's your choice to use either.

And then, neither sizeof nor pointer increment really returns the size of the operand, instead, they both return the amount of memory occupied per object when they are made an array.

Try something like:

struct myStruct
{
   double a;
   char b;
}

then sizeof(struct myStruct) is very likely to be 2*sizeof(double) , not sizeof(double)+sizeof(char) , because the next array element when you make an array of myStruct has to be that far away.

Is myStruct really using that much space? Probably not.

if you do something like:

struct myBigStruct
{
   struct myStruct small;
   char b;
}

then sizeof(struct myBigStruct) is very likely to be still 2*sizeof(double) , not sizeof(struct myStruct)+sizeof(char)

All these are implementation dependent.

It's just because too many people assumes sizeof(type[N]) == N*sizeof(type) so C forces it to be true by making sizeof this way.