Programming

Because the compiler's doing pointer arithmetic and the difference between 2 succesive pointers is 1. To get the size of any variable that is of that structure type it needs to be cast to an unsigned int...

Code:

/* size of any variable of that structure type */
s = (unsigned) &a[1] - (unsigned) &a[0];

/* size of the array will be */
100 * s;

Cast it into an unsigned long instead. unsigned int will truncate a pointer on a lot of architectures.

If you can do array operations on it like that, the compiler knows the size, so sizeof will work.

Code:

sizeof(a[0]) * 100

Only on compilers that are strictly 64-bit since they use the LP64 model. Majority of systems in use today are ILP32 so unsigned int is the same as unsigned long but for the sake of portability it should be unsigned long.

Well it was all about determining the size of an array of structures without using sizeof.

This is because, compiler 'knows' type of array and it places instructions of pointer arithmetic using size of 'type'.

so &array[1] - &array[0] = number of elements of type of 'array' between &array[1] and &array[0]

Try this (char*)&array[1] - (char*)&array[0] or (unsigned long)(&array[1]) - (unsigned long)(&array[0])

fine. thank you.
#include <stdio.h>

#pragma pack(1)

main()
{

char begin;
struct ptr
{
int a;
char b;
int *p;
}abc;
char end;

printf("Using sizeof operator = %u\n", sizeof(abc));

printf("Begin address = %u \n",&begin);
printf("end address = %u \n",&end);
printf("first element in struct address = %u \n",&abc.a);
printf("sizeof the structure = %u \n",(&begin > &end) ? (&begin - &end - 1) : (&end - &begin - 1));

}
The sizeof the structure using 'sizeof' operator is 9 as we are using #pragma pack(1)

But if you use the (&begin - &end - 1) logic the size is 15 which is wrong. It is because the
address of end variable is say 1245036
and the address of the first element in the structure is 1245040
and the begin variable address is 1245052.

The first element of the structure is in the address which is a multiple of 4 and within structure we have a 'char' which is not padded and the int * starts immediately after that. but once it comes out of the structure again the 'begin' variable is in multiple of 4. Does it mean #pragma pack(1) packs only the variable inside the structure to avoid structure padding? if it is so then why when we declare
#include <stdio.h>
#pragma pack(1)
struct array
{
int a;
char c;
int d;
int e;
int f;
int h;
};

int main()
{
char begin;
struct array a[100];
char end;
printf("Size of structure = %u ", (&begin > &end) ? (&begin - &end - 1)/100 : (&end - &begin - 1)/100);
}

Here both sizeof operator and the program logic gives the same output 21 which is correct. Am not clear why it is not behaving properly in the below mentioned code. Could someone explain it to me?

main()
{

char begin;
struct ptr
{
int a;
char b;
int *p;
}abc;
char end;