Tru64 UNIX
Compaq C Language Reference Manual


Previous Contents Index


struct person 
   { 
      char first[20]; 
      char middle[3]; 
      char last[30]; 
   }  employees, managers; 

  • If the tag is omitted, the structure or union definition applies only to the identifiers that follow in the declaration. For example:


    struct 
       { 
          char first[20]; 
          char middle[3]; 
          char last[30]; 
       }  employees, managers; 
    

  • The tag can refer to a structure or union type defined elsewhere. The definition is then applied to the variable identifiers that follow the tag name in the declaration, as in the following example:


    struct   person   employees, managers; 
    

  • Another form uses only the struct or union keyword and the tag to override other identical tags in the scope, and to reserve the tag for a later definition within a new scope. A definition within a new scope overrides any previous tag definition appearing in an outer scope. This use of declaring tags is called tentative structure tag declaration. Using such declarations, you can eliminate ambiguity when making a forward reference to tag identifiers. The following example shows such a case:


    struct  A {...};  /*  Definition of external struct A               */ 
     
    { 
       struct A;   /*  Tentative structure tag declaration.               */ 
                   /*  First declaration of A (in external scope) is 
                       hidden. This structure will be defined later     */ 
       struct  inner 
       { 
          struct A *pointer;          /* Declare a structure pointer by */ 
           .                          /* forward referencing.           */ 
           . 
           . 
       }; 
     
       struct A {...};  /* Tentative declaration of internal struct A is 
                           defined here.                                */ 
                   /* External struct A is unaffected by this definition*/ 
    } 
    

    In the example, the pointer to the structure defined using the tag A points to the internal definition of A , not the external definition.

    4.8.1 Similarities Between Structures and Unions

    Structures and unions share the following characteristics:

    4.8.2 Differences Between Structures and Unions

    The difference between structures and unions lies in the way their members are stored and initialized, as follows:

    4.8.3 Bit Fields

    One of the advantages of structures is the ability to pack data into them bit-by-bit.

    A structure member often is an object with a basic type size. However, you can also declare a structure member that is composed only of a specified number of bits. Such a member is called a bit field; its length, an integral nonnegative constant expression, is set off from the field name by a colon, as shown by the following syntax:

    struct-declarator:

    declarator: constant-expression
    :constant-expression

    Bit fields provide greater control over the structure's storage allocation and allow tighter packing of information in memory. By using bit fields, data can be densely packed into storage.

    A bit field's type must be specified (except with unnamed bit fields), and a bit field can have the int , unsigned int , or signed int type. The bit field's value must be small enough to store in an object of the declared size.

    In the compiler's default mode, the enum , long , short , and char types are also allowed for bit fields.

    A bit field can be named or unnamed. A bit-field declaration without a declarator (for example, :10 ) indicates an unnamed bit field, which is useful for padding a structure to conform to a specified layout. If the bit field is assigned a width of 0, it indicates that no further bit fields should be placed in the alignment unit, and it cannot name a declarator. Use a colon (:) to separate the member's declarator (if any) from a constant expression that gives the field width in bits. No field can be longer than 32 bits (1 longword).

    Since nonbit-field structure members are aligned on at least byte boundaries, the unnamed form can create unnamed gaps in the structure's storage. As a special case, an unnamed field of width 0 causes the next member (normally another field) to be aligned on at least a byte boundary; that is, a bit-field structure member with zero width indicates that no further bit field should be packed into an alignment unit.

    The following restrictions apply to the use of bit fields:

    Sequences of bit fields are packed as tightly as possible. In C, bit fields are assigned from right to left; that is, from low-order to high-order bit.

    To create bit fields, specify an identifier, a colon, and the identifier's width (in bits) as a structure member. In the following example, three bit fields are created in the structure declaration:


    struct { 
     unsigned int a : 1;  /*  Named bit field (a)    */ 
     unsigned int   : 0;  /*  Unnamed bit field = 0  */ 
     unsigned int   : 1;  /*  Unnamed bit field      */ 
    }  class; 
    

    The first and third bit fields are one bit wide, the second is zero bits wide, which forces the next member to be aligned on a natural or byte boundary.

    Bit fields (including zero-length bit fields) not immediately declared after other bit fields have the alignment requirement imposed by their type, but never a lesser alignment requirement than that of int . In a declaration of a bit field that immediately follows another bit field, the bits are packed into adjacent space in the same alignment unit, if sufficient space remains; otherwise, padding is inserted and the second bit field is put into the next alignment unit.

    See your Compaq C documentation for platform-specific information on bit-field alignment within a structure.

    4.8.4 Initializing Structures

    All structures can be initialized with a brace-enclosed list of component initializers. Structures with automatic storage class can also be initialized by an expression of compatible type.

    Initializers are assigned to components on a one-to-one basis. If there are fewer initializers than members for a structure, the remaining members are initialized to 0. Listing too many initializers for the number of components in a structure is an error. All unnamed structure or union members are ignored during initialization.

    Separate initializing values with commas and delimit them with braces { }. The following example initializes two structures, each with two members:


    struct 
       { 
          int i; 
          float c; 
       }  a = { 1, 3.0e10 },  b = { 2, 1.5e5 }; 
    

    The compiler assigns structure initializers in increasing member order. Note that there is no way to initialize a member in the middle of a structure without also initializing the previous members. Example 4-1 shows the initialization rules applied to an array of structures.

    Example 4-1 The Rules for Initializing Structures

    #include <stdio.h> 
     
    main() 
    { 
       int m, n; 
       static struct 
          { 
             char ch; 
             int i; 
             float c; 
          }  ar[2][3] = 
    (1)         { 
    (2)            { 
    (3)               { 'a', 1, 3e10 }, 
                   { 'b', 2, 4e10 }, 
                   { 'c', 3, 5e10 }, 
                } 
             }; 
     
       printf("row/col\t ch\t i\t      c\n"); 
       printf("-------------------------------------\n"); 
       for (n = 0; n < 2; n++) 
          for (m = 0; m < 3; m++) 
             { 
                printf("[%d][%d]:", n, m); 
                printf("\t %c \t %d \t %e \n", 
                       ar[n][m].ch, ar[n][m].i, ar[n][m].c); 
             } 
    } 
    

    Key to Example 4-1:

    1. Delimit an array row initialization with braces.
    2. Delimit a structure initialization with braces.
    3. Delimit an array initialization with braces.

    Example 4-1 writes the following output to the standard output:


    row/col  ch      i            c 
    ------------------------------------- 
    [0][0]:  a       1       3.000000e+10 
    [0][1]:  b       2       4.000000e+10 
    [0][2]:  c       3       5.000000e+10 
    [1][0]:          0       0.000000e+00 
    [1][1]:          0       0.000000e+00 
    [1][2]:          0       0.000000e+00 
    

    Note

    See Section 4.9 for a description of initializers with designations for arrays and structures.

    4.8.5 Initializing Unions

    Unions are initialized with a brace-enclosed initializer that initializes only the first member of the union. For example:


    static union 
      { 
         char ch; 
         int i; 
         float c; 
      } letter = {'A'}; 
    

    Unions with the auto storage class may also be initialized with an expression of the same type as the union. For example:


    main () 
    { 
    union1 { 
        int i; 
        char ch; 
        float c; 
      } number1 = { 2 }; 
     
    auto union2 
      { 
        int i; 
        char ch; 
        float c; 
      } number2 = number1; 
    } 
    

    4.9 Initializers with Designations

    In conformance with the C99 standard, Compaq C supports the use of designations in the initialization of arrays and structures. (Note that designations are not supported in the common C, VAX C, and Strict ANSI89 modes of the compiler.)

    4.9.1 Current Object

    C99 initializers introduce the concept of a current object and a designation.

    The current object is the next thing to be initialized during the initialization of an array or structure.

    A designation provides a way to set the current object. When no designations are present, subobjects of the current object are initialized in order according to the type of the object: array elements in increasing subscript order, and structure members in declaration order.

    So for an array, the first current object is a[0] when initialization begins; as each initializer is used, the current object is bumped to the next initializer, in increasing subscript order.

    Similarly, for a structure, the current object is the first declaration within the structure when initialization begins; as each initializer is used, the current object is bumped to the next initializer, in declaration order.

    4.9.2 Designations

    The C99 Standard allows brace-enclosed initializer lists to contain designations, which specify a new current object. The syntax for a designation is:


            designation: 
                    designator-list = 
     
            designator-list: 
                    designator 
                    designator-list designator 
     
            designator: 
                    [ constant-expression ] 
                    . identifier 
    

    A designator within a designation causes the following initializer to begin initialization of the object described by the designator. Initialization then continues forward, in order, beginning with the next object after that described by the designator.

    For an array, a designator looks like this:

    [ integral-constant-expression ]

    If the array is of unknown size, any nonnegative value is valid.

    For a structure, a designator looks like this:

    .identifier

    Where identifier is a member of the structure.

    4.9.3 Examples

    The old way of initializing arrays and structures is still supported. However, the use of designators can simplify coding of initializer lists and better accommodate future changes you might want to make to arrays and structures in your application.

    1. Using designators, array elements can be initialized to nonzero values without depending on their order:


      int a[5] = { 0, 0, 0, 5 };  // Old way 
       
      int a[5] = { [3]=5 };       // New way 
      

      The designator [3] initializes a[3] to 5.

    2. Structure members can be initialized to nonzero values without depending on their order. For example:


       typedef struct { 
            char flag1; 
            char flag2; 
            char flag3; 
             int data1; 
             int data2; 
             int data3; 
             } Sx; 
       
      Sx = { 0, 0, 0, 0, 6 };   // Old way 
       
      Sx = { .data2 = 6 };      // New way 
      

      Designator .data2 initializes structure member .data2 to 6.

    3. Another example of using designators in an array:


      int a[10] = { 1, [5] = 20, 10 }; 
      

      In this example, the array elements are initialized as follows:


      a[0]=1 
      a[1] through a[4] = 0 
      a[5] = 20 
      a[6] = 10 
      a[7] through a[9] = 0 
      

    4. Future changes to structures can be accommodated without changing their initializer lists:


       typedef struct { 
            char flag1; 
            char flag2; 
            char flag3; 
             int data1; 
             int data2; 
             int data3; 
             } Sx; 
       
      Sx = { 1, 0, 1, 65, 32, 18 };   // Old way 
       
      Sx = { .flag1=1, 0, 1, .data1=65, 32, 18 }; // New way 
      

      Use of designators .flag1 and .data1 allows for future insertion of additional flags in front of .flag1 or between flag3 and data1.
      Designators do not have to be in order. For example, the following two initializer lists are equivalent:


      Sx = { .data1=65, 32, 18, .flag1=1, 0, 1 }; 
       
      Sx = { .flag1=1, 0, 1, .data1=65, 32, 18 }; 
      

    5. Space can be "allocated" from both ends of an array by using a single designator:


      int a[MAX] = 
      { 
          1, 3, 5, 7, 9, [MAX - 5] = 8, 6, 4, 2, 0 
      };      
      

      In this example, if MAX is greater than 10, there will be some zero-valued elements in the middle; if it is less than 10, some of the values provided by the first five initializers will be overridden by the second five.

    6. Designators can be nested:


      struct { int a[3], b } w[] = 
      { [0].a = {1}, [1].a[0] = 2 }; 
      

      This initialization is equivalent to the following:


      w[0].a[0]=1; 
      w[1].a[0]=2; 
      

    7. Another example of nesting designators:


      struct { 
           int a; 
           struct { 
                int b 
                int c[10] 
           }x; 
      }y = {.x = {1, .c = {[5] = 6, 7 }}}    
      

      This initialization is equivalent to the following:


      y.x.b = 1; 
      y.x.c[5] = 6; 
      y.x.c[6] = 7; 
      

    4.10 Declaring Tags

    The following syntax declares the identifier tag as a structure, union, or enumeration tag. If this tag declaration is visible, a subsequent reference to the tag substitutes for the declared structure, union, or enumerated type. Subsequent references of the tag in the same scope (visible declarations) must omit the bracketed list. The syntax of a tag is:

    struct tag { declarator-list }


    union tag { declarator-list }


    enum tag { enumerator-list }

    If the tag is declared without the complete structure or union declaration, it refers to an incomplete type. Incomplete enumerated types are illegal. An incomplete type is valid only to specify an object where the type is not required; for example, during type definitions and pointer declarations. To complete the type, another declaration of the tag in the same scope (but not within an enclosed block), defines the content.

    The following construction uses the tag test to define a self-referencing structure.


    struct test { 
     float height; 
     struct test *x, *y, *z; 
    }; 
    

    Once this declaration is given, the following declaration declares s to be an object of type struct test and sp to be a pointer to an object of type struct test :


    struct test s, *sp; 
    

    Note

    The keyword typedef can also be used in an alternative construction to do the same thing:


    typedef struct test tnode; 
    struct test { 
         float height; 
         tnode *x, *y, *z; 
    }; 
    tnode s, *sp; 
    


    Previous Next Contents Index