sizeof()

[Jack]

For the structure below:

struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

The output is
sizeof(A): 16

Why it is 16?

Thanks.

Jack

[Tom St Denis]

Jack wrote:

For the structure below:

struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

The output is
sizeof(A): 16

Why it is 16?

why not?

Tom

[Robert Gamble]

Jack wrote:

For the structure below:

struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

The output is
sizeof(A): 16

Why it is 16?

Read the FAQ, <http://c-faq.com/>, question 2.13.

Robert Gamble

[Walter Roberson]

In article <11************ *********@i3g20 00cwc.googlegro ups.com>,
Jack <ju******@gmail .comwrote:

>For the structure below:

>struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

>The output is
sizeof(A): 16

>Why it is 16?

That implementation probably uses 4 bytes for int, 8 bytes for double,
1 byte for char. But implementations are required to pad structures so
that the size of the structure is a multiple of the architectural
alignment restrictions (often 4 bytes), so the structure likely gets
padded by adding 3 unused bytes.

If the structure were not padded, then if you had

struct A sa2[2];

then the address of sa2[1] would be 13 bytes after the start of sa2[0]
and you would be asking the system to read an int from an odd byte
address. A lot of systems cannot do that, or can only do that by using
special trap handlers, or can only do it by using special
"load unaligned" instructions that are often very slow.
--
"law -- it's a commodity"
-- Andrew Ryan (The Globe and Mail, 2005/11/26)

[Roberto Waltman]

"Jack" <ju******@gmail .comwrote:

>For the structure below:

struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

The output is
sizeof(A): 16

Why it is 16?

Probably because sizeof(int) is 4, sizeof(double) is 8, sizeof(char)
is 1 (of course,) and 3 chars of padding are added to guarantee proper
alignment.

But it could also be that in your machine sizeof(int) is 1,
sizeof(double) is 14 and no padding is necessary.

Or maybe sizeof(int) is 7, followed by one char padding,
sizeof(double) is 5, followed by one char padding, plus the size of c
and one last char of padding for alignment.

Or any other valid combination adding up to 16.

Check your compiler's documentation for the sizes of the primitive
data types and alignment requirements.

Roberto Waltman

[ Please reply to the group,
return address is invalid ]

[dbtid]

Tom St Denis wrote:

Jack wrote:

>For the structure below:

struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

The output is
sizeof(A): 16

Why it is 16?

why not?

Tom

What a useless answer.

Why not just tell him there is padding?

[jaysome]

On 19 Jul 2006 08:58:01 -0700, "Robert Gamble" <rg*******@gmai l.com>
wrote:

>Jack wrote:

>For the structure below:

struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

The output is
sizeof(A): 16

Why it is 16?

Read the FAQ, <http://c-faq.com/>, question 2.13.

which says:

Q. Why does sizeof report a larger size than I expect for a structure
type, as if there were padding at the end?

A. Padding at the end of a structure may be necessary to preserve
alignment when an array of contiguous structures is allocated. Even
when the structure is not part of an array, the padding remains, so
that sizeof can always return a consistent size. See also question
2.12.

References: H&S Sec. 5.6.7 pp. 139-40

Best regards
--
jay

NOTE: The C FAQ book has the same contents as the online C FAQ and
more. The online version is great and the book is even better. Find
out more here:

http://c-faq.com/book/

[sarathy]

Walter Roberson wrote:

In article <11************ *********@i3g20 00cwc.googlegro ups.com>,
Jack <ju******@gmail .comwrote:

For the structure below:

struct A{
int a;
double b;
char c;
};

struct A sa;
printf("sizeof( A): %d\n", sizeof(sa));

The output is
sizeof(A): 16

Why it is 16?

That implementation probably uses 4 bytes for int, 8 bytes for double,
1 byte for char. But implementations are required to pad structures so
that the size of the structure is a multiple of the architectural
alignment restrictions (often 4 bytes), so the structure likely gets
padded by adding 3 unused bytes.

If the structure were not padded, then if you had

struct A sa2[2];

then the address of sa2[1] would be 13 bytes after the start of sa2[0]
and you would be asking the system to read an int from an odd byte
address. A lot of systems cannot do that, or can only do that by using
special trap handlers, or can only do it by using special
"load unaligned" instructions that are often very slow.
--
"law -- it's a commodity"
-- Andrew Ryan (The Globe and Mail, 2005/11/26)

What does it mean that system cannot read odd byte address ?
Is this due to the concept of word length, which is the basic length of
a memory address.
If such is the case, then how is memory allocated for following case.

Consider that word length is 4. For the struct,

struct a
{
char c;
};
int main()
{
struct a b[10];
printf ("size = %d\n",sizeof(b) );
}

As per the discussion, should the answer be 40 (3 bytes padded for
evrey 1 char)????
so that there is not need for reading odd byte address?
Correct me if this not true.

Sarathy

[Richard Tobin]

In article <11************ **********@s13g 2000cwa.googleg roups.com>,
sarathy <sp*********@gm ail.comwrote:

>and you would be asking the system to read an int from an odd byte
address. A lot of systems cannot do that

>What does it mean that system cannot read odd byte address ?

He said read *an int* from an odd byte address. Many modern machines
can read a single byte from any location, but a 2-byte word only from
even addresses, a 4-byte word only from multiple-of-4 addresses, and
so on.

>Consider that word length is 4. For the struct,

struct a
{
char c;
};
int main()
{
struct a b[10];
printf ("size = %d\n",sizeof(b) );
}

As per the discussion, should the answer be 40 (3 bytes padded for
evrey 1 char)????

In this case, you never need to read anything bigger than char, so alignment
isn't likely to be a problem. sizeof(b) will probably be 10.

-- Richard

[Giorgio Silvestri]

"Richard Tobin" <ri*****@cogsci .ed.ac.ukha scritto nel messaggio
news:e9******** ***@pc-news.cogsci.ed. ac.uk...

In article <11************ **********@s13g 2000cwa.googleg roups.com>,
sarathy <sp*********@gm ail.comwrote:

and you would be asking the system to read an int from an odd byte
address. A lot of systems cannot do that

What does it mean that system cannot read odd byte address ?

He said read *an int* from an odd byte address. Many modern machines
can read a single byte from any location, but a 2-byte word only from
even addresses, a 4-byte word only from multiple-of-4 addresses, and
so on.

Consider that word length is 4. For the struct,

struct a
{
char c;
};
int main()
{
struct a b[10];
printf ("size = %d\n",sizeof(b) );
}

No.

sizeof(b) is of type 'size_t'.
It can be bigger than 'int'.
#include <stdio.h>
#include <stdlib.h>

struct a
{
char c;
};

int main(void)
{
struct a b[10];

/* I suppose sizeof(b) <= INT_MAX :-) */
printf ("size = %d\n",(int)size of(b));

return EXIT_SUCCESS;
}

In C99 you can use also %zu.

Giorgio Silvestri