December 18 2006

#pragma

  Each implementation of C and C++ supports some features unique to its host machine or operation
system.  Some programs, for instance, need to exercise precise control over the memory areas where
data is placed or to control the way certain functions receive parameters.  The #pragma directives
offer a way for each compiler to offer machine- and operating-system-specific features while retaining
overall compatibility with the C and C++ languages.  Pragmas are machine- or operating-system-specific
by definition, and are usually different for every compiler.

  #pragma pack([n])

  Specifies packing alignment for structure and union members.  Whereas the packing alignment of structures
and unions is set for an entire translation unit by the /Zp option, the packing alignment is set at
the data-declaration level by the pack pragma.  The pragma takes effect at the first structure or
union declaration after the pragma is seen; the pragma has no effect on definitions.  When you use
#pragma pack(n), where n is 1, 2, 4, 8, or 16, each structure member after the first is stored on
the smaller member type or n-byte boundaries.  If you use #pragma pack without an argument, structure
members are packed to the value specified by /Zp.  The default /Zp packing size is /Zp8.

  The compiler also supports the following enhanced syntax:

  #pragma pack( [ [ { push | pop}, ] [  identifier, ] ] [ n ] )

  This syntax allows you to combine program components into a single translation unit if the different
components use pack pragmas to specify different packing alignments.  Each occurrence of a pack pragma
with a push argument stores the current packing alignment on an internal compiler stack.  The pragma’s
argument list is read from left to right. If you use push, the current packing value is stored.  If you
provide a value for n, that value becomes the new packing value. If you specify an identifier, a name of
your choosing, the identifier is associated with the new packing value.

  Each occurrence of a pack pragma with a pop argument retrieves the value at the top of an internal
compiler stack and makes that value the new packing alignment.  If you use pop and the internal compiler
stack is empty, the alignment value is that set from the command-line and a warning is issued.  If you
use pop and specify a value for n, that value becomes the new packing value.  If you use pop and specify
an identifier, all values stored on the stack are removed from the stack until a matching identifier is
found.  The packing value associated with the identifier is also removed from the stack and the packing
value that existed just before the identifier was pushed becomes the new packing value.  If no matching
identifier is found, the packing value set from the command line is used and a level-one warning is issued.
The default packing alignment is 8.

  The new, enhanced functionality of the pack pragma allows you to write header files that ensure that
packing values are the same before and after the header file is encountered:

/* File name: include1.h*/
#pragma pack( push, enter_include1 )
/* Your include-file code ... */
#pragma pack( pop, enter_include1 )
/* End of include1.h */

  In the previous example, the current pack value is associated with the identifier enter_include1 and
pushed, remembered, on entry to the header file.  The pack pragma at the end of the header file removes
all intervening pack values that may have occurred in the header file and removes the pack value associated
with enter_include1.  The header file thus ensures that the pack value is the same before and after the
header file.

  The new functionality also allows you to use code, such as header files, that uses pack pragmas to
set packing alignments that differ from the packing value set in your code:

#pragma pack( push, before_include1 )
#include "include1.h"
#pragma pack( pop, before_include1 )

In the previous example, your code is protected from any changes to the packing value that might occur
in include.h.