very important about the size
the allocation of structure members in Compaq C v6.5 for openVMS system
Size of structure members (very important!)
OS is OpenVMS (TM) Alpha Operating System(Version V7.3-2),I had made a program for testing:
#include
void main()
{
struct test1{
char a; // 1 byte(+3 bytes as filler follow a)
int b; // 4 bytes
short c; // 2 bytes(+2 bytes as filler follow c)
}abc; //12 bytes
struct test2{
char d; // 1 byte
}ddd;
struct test{
struct test3{
char a; // 1 byte(+3 bytes as filler follow a)
int b; // 4 bytes
short c; // 2 bytes(+2 bytes as filler follow c)
}_abc; //12 bytes
struct test4{
char d; // 1 bytes(+3 bytes as filler follow d)
}_ddd;
}abcd; // 16 bytes 4*4=16
float e; // 4 bytes
double f; // 8 bytes
printf("abc = %d n",sizeof (abc));
printf("ddd = %d n",sizeof (ddd));
printf("abcd = %d n",sizeof (abcd));
printf("e = %d n",sizeof (e));
printf("f = %d n",sizeof (f));
}
ca *.c //ca="CC/FLOAT=IEEE_FLOAT/INCLUDE_DIRECTORY=(???ignored)/LIST"
link *
link.com:
$ SET VER
$ LINK/MAP='P1' /EXE='P1' 'P1', ???ignored/OPT, -
ora_proc:oraclient/opt,-
.../LIB,-
???ignored/LIB,-
???ignored/LIB,-
???ignored/LIB,-
???ignored/LIB,-
???ignored/LIB,-
???ignored/LIB,-
???ignored/OPT, ???ignored:???ignored/LIB
$ SET NOVER
the result is :
abc = 12
ddd = 1
abcd = 16
e = 4
f = 8
-nomember_alignment
Direct the compiler to byte-align data structure members (with the exception of bit-field members). By default, data structure members are aligned on natural boundaries (the next boundary appropriate to the type of the member) rather than the next byte. For example, an int variable member is aligned on the next longword boundary; a short variable member is aligned on the next word boundary. Using any of the #pragma member_alignment , #pragma nomember_alignment , and #pragma pack directives within the source code overrides the setting established by this option.
-Zp n
Align structure members on alignment specified by the integer n, where n can be 1, 2, or 4. This option specifies packing so that each structure member after the first is stored on n-byte boundaries as specified by the flag you choose. When you specify the -Zp option without an n value, structure members are packed on 1-byte boundaries.
If under turbo c 2.0 & window xp :
pattern size
char 1 byte
int 2 bytes
unsigned int 2 bytes
signed int 2 bytes
float 4bytes
double 8 bytes
#pragma [no]member_alignment Directive
By default, Compaq C for OpenVMS VAX systems does not align structure members on natural boundaries; they are stored on byte boundaries (with the exception of bit-field members).
By default, Compaq C for OpenVMS Alpha systems does align structure members on natural boundaries.
The #pragma member_alignment preprocessor directive can be used to force natural-boundary alignment of structure members. The #pragma nomember_alignment preprocessor directive restores byte-alignment of structure members.
This pragma has the following formats:
#pragma member_alignment
#pragma member_alignment save
#pragma member_alignment restore
#pragma nomember_alignment [base_alignment]
When #pragma member_alignment is used, the compiler aligns structure members on the next boundary appropriate to the type of the member, rather than on the next byte. For example, a long variable is aligned on the next longword boundary; a short variable is aligned on the next word boundary.
Consider the following example:
#pragma nomember_alignment
struct x {
char c; //1byte
int b; //4bytes
};
#pragma member_alignment
struct y {
char c; //4bytes /*3 bytes of filler follow c */
int b; //4bytes
};
main ()
{
printf( "The sizeof y is: %dn", sizeof (struct y) );
printf( "The sizeof x is: %dn", sizeof (struct x) );
}
When this example is executed, it shows the difference between #pragma member_alignment and #pragma nomember_alignment .
Once used, the member_alignment pragma remains in effect until the nomember_alignment pragma is encountered; the reverse is also true.
The optional base_alignment parameter can be used to specify the base-alignment of the structure. Use one of the following keywords for the base_alignment:
byte (1 byte)
word (2 bytes)
longword (4 bytes)
quadword (8 bytes)
octaword (16 bytes)
The #pragma member_alignment save and #pragma member_alignment restore directives can be used to save the current state of the member_alignment and to restore the previous state, respectively. This feature is necessary for writing header files that require member_alignment or nomember_alignment , or that require inclusion in a member_alignment that is already set.