Arrays are initialized with a brace-enclosed list of constant expressions. A list of initializers for an incomplete array declaration completes the array's type and completely defines the array size. Therefore, when initializing an array of unknown size, the number of initializers in the initializer list determines the size of the array. For example, the following declaration initializes an array of three elements:

int x[] = { 1, 2, 3 };

If the array being initialized has a storage class of static , the initializers must be constant expressions.

Initializers for an array of a given size are assigned to array members on a one-to-one basis. If there are too few initializers for all members, the remaining members are initialized to 0. Listing too many initializers for a given size array is an error. For example:

int x[5] = { 0, 1, 2, 3, 4, 5 }; /* error */

String literals are often assigned to a char or wchar_t array. In this case, each character of the string represents one member of a one-dimensional array, and the array is terminated with the null character. When an array is initialized by a pointer to a string literal, the string literal cannot be modified through the pointer.

When initializing an array with a string literal, use quotation marks around the initializing string. For example:

char string[26] = { "This is a string literal." }; /* The braces above are optional here */

The terminating null character is appended to the end of the string if the size permits, as it does in this case. Another form for initializing an array with characters is the following:

char string[12] = {'T', 'h', 'i', 's', ' ', 'w', 'a', 'y' };

The preceding example creates a one-dimensional array containing the string value " This way ". The characters in this array can be freely modified. Remaining uninitialized array members will be automatically initialized to zero.

If the size of the array used for a string literal is not explicitly stated, its size is determined by the number of characters in the string (including the terminating null character). If the size of the array is explicitly stated, initializing the array with a string literal longer than the array is an error.

Using the following rules, you can omit braces when initializing the members of a multidimensional arrays:

• When initializing arrays, you can omit the outermost pair of braces.
• If the initializer list includes all of the initializers for the object being initialized, you can omit the inner braces.

Consider the following example:

float x[4][2] = { { 1, 2 } { 3, 4 } { 5, 6 } };

In this example, 1 and 2 initialize the first row of the array x , and the following two lines initialize the second and third rows, respectively. The initialization ends before the fourth row is initialized, so the members of the fourth row default to 0. Here is the result:

x[0][0] = 1; x[0][1] = 2; x[1][0] = 3; x[1][1] = 4; x[2][0] = 5; x[2][1] = 6; x[3][0] = 0; x[3][1] = 0;

The following declaration achieves the same result:

float x[4][2] = { 1, 2, 3, 4, 5, 6 };

Here, the compiler fills the array row by row with the available initial values. The compiler places 1 and 2 in the first row ( x[0] ), 3 and 4 in the second row ( x[1] ), and 5 and 6 in the third row ( x[2] ). The remaining members of the array are initialized to zero.

Data objects in an array can be referenced through pointers instead of using array subscripts. The data type of such a pointer is referred to as "pointer to array of type". The array name itself behaves like a pointer, so there are several alternative methods to accessing array elements. For example:

int x[5] = { 0, 1, 2, 3, 4 }; /* Array x declared with five elements */ int *p = x; /* Pointer declared and initialized to point */ /* to the first element of the array x */ int a, b; a = *(x + 3); /* Pointer x incremented by twelve bytes */ /* to reference element 3 of x */ b = x[3]; /* b now holds the same value as a */

In the previous example, a receives the value 3 by using the dereferencing operator (*). b receives the same value by using the subscripting operator. See Chapter 6 for more information on the different unary operators.

Note that the assignment of a was a result of incrementing the pointer to x . This principle, known as scaling, applies to all types of pointer arithmetic. In scaling, the compiler considers the size of an array element when calculating memory addresses of array members. For example, each member of the array x is 4 bytes long, and adding three to the initial pointer value automatically converts that addition to 3 * (the size of the array member, which in this case is 4). Therefore, the intuitive meaning of z = *(y + 3); is preserved.

When passing arrays as function arguments, only a pointer to the first element of the array is passed to the called function. The conversion from array type to pointer type is implicit. Once the array name is converted to a pointer to the first element of the array, you can increment, decrement, or dereference the pointer, just like any other pointer, to manipulate data in the array. For example:

int func(int *x, int *y) /* The arrays are converted to pointers */ { *y = *(x + 4); /* Various elements of the arrays are accessed */ }

Remember that a pointer is large enough to hold only an address; a pointer into an array holds the address of an element of that array. The array itself is large enough to hold all members of the array.

When applied to arrays, the sizeof operator returns the size of the entire array, not just the size of the first element in the array.

4.7.3 Variable-Length Arrays

Variable-length arrays allow array objects with auto storage class, and array typedef s declared at block scope, to have bounds that are runtime-computed expressions.

Variable-length arrays also allow the declaration and definition of functions whose parameters are arrays dimensioned by other parameters (similar to Fortran assumed-shape arrays).

The following example illustrates both uses. Note that the definition of function sub uses prototype syntax and that the dimension parameters precede the array parameter that uses them. In order to define a function with the dimension parameters following the array parameter that uses them, the function definition must be written using using Kernighan and Ritchie C syntax (because that syntax allows the declarations of the types of the parameters to be written in a different order from the parameters themselves). Kernighan and Ritchie function definitions should generally be avoided.

#include <stdio.h> #include <stdlib.h> void sub(int, int, int[*][*]); int main(int argc, char **argv) { if (argc != 3) { printf("Specify two array bound arguments.\n"); exit(EXIT_FAILURE); } { int dim1 = atoi(argv[1]); int dim2 = atoi(argv[2]); int a[dim1][dim2]; int i, j, k = 0; for (i = 0; i &lt; dim1; i++) { for (j = 0; j &lt; dim2; j++) { a[i][j] = k++; } } printf("dim1 = %d, dim2 = %d.", sizeof(a)/sizeof(a[0]), sizeof(a[0])/sizeof(int)); sub(dim1, dim2, a); sub(dim2, dim1, a); } exit(EXIT_SUCCESS); } void sub(int sub1, int sub2, int suba[sub1][sub2]) { int i, j, k = 0; printf("\nIn sub, sub1 = %d, sub2 = %d.", sub1, sub2); for (i = 0; i &lt; sub1; i++) { printf("\n"); for (j = 0; j &lt; sub2; j++) { printf("%4d", suba[i][j]); } } }

On OpenVMS systems, variable-length arrays can often be used in place of the non-standard alloca intrinsic, __alloca .

However, an important difference between __alloca and variable-length arrays is that the storage allocated by __alloca is not freed until return from the function, while the storage allocated for a variable-length array is freed on exit from the block in which it is allocated. If __alloca is called within the scope of a variable-length array declaration (including within a block nested within the block containing a variable-length array declaration), then the storage allocated by that call to __alloca is freed at the same time that the storage for the variable-length array is freed (that is, at block exit rather than at function return). The compiler issues a warning in such cases.

4.8 Declaring Structures and Unions

A structure consists of a list of members whose storage is allocated in an ordered sequence. A union consists of a sequence of members whose storage overlaps. Structure and union declarations have the same form, as follows:

struct-or-union-specifier:

struct-or-union identifieropt { struct-declaration-list} struct-or-union identifier

struct-or-union:

struct union

struct-declaration-list:

struct-declaration struct-declaration-list struct-declaration

struct-declaration:

specifier-qualifier-list struct-declarator-list ;

specifier-qualifier-list:

type-specifier specifier-qualifier-listopt type-qualifier specifier-qualifier-list opt

struct-declarator-list:

struct-declarator struct-declarator-list , struct-declarator

struct-declarator:

declarator declaratoropt : constant-expression

Neither a structure nor union member can have a function type or an incomplete type. Structures and unions cannot contain instances of themselves as members, but they can have pointers to instances of themselves as members. The declaration of a structure with no members is accepted; its size is zero.

Each structure or union definition creates a unique structure or union type within the compilation unit. The struct or union keywords can be followed by a tag, which gives a name to the structure or union type in much the same way that an enum tag gives a name to an enumerated type. The tag can then be used with the struct or union keywords to declare variables of that type without repeating a long definition.

The tag is followed by braces { } that enclose a list of member declarations. Each declaration in the list gives the data type and name of one or more members. The names of structure or union members can be the same as other variables, function names, or members in other structures or unions; the compiler distinguishes them by context. In addition, the scope of the member name is the same as the scope of the structure or union in which it appears. The structure or union type is completed when the closing brace completes the list.

An identifier used for a structure or union tag must be unique among the visible tags in its scope, but the tag identifier can be the same as an identifier used for a variable or function name. Tags can also have the same spellings as member names; the compiler distinguishes them by name space and context. The scope of a tag is the same as the scope of the declaration in which it appears.

Structures and unions can contain other structures and unions. For example:

struct person { char first[20]; char middle[3]; char last[30]; struct /* Nested structure here */ { int day; int month; int year; } birth_date; } employees, managers;

Structure or union declarations can take one of the following forms:

• If a declaration includes only a tag and a list of member declarations, then the list of member declarations defines the tag to be a data type by which other objects can be declared. The tag is considered a shorthand notation for the structure type. For example:

  struct person { char first[20]; char middle[3]; char last[30]; }; struct person employee; /* The tag (person) identifies employee as */ a structure with members shown in */ the declaration of person */

• When a declaration includes a tag, a list of member declarations, and a list of identifiers, the identifiers become objects of the structure type and the tag is considered a shorthand notation, or mnemonic, for the structure type. The following example shows this:

  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.

Structures and unions share the following characteristics:

• Their members can be objects of any type, including other structures and unions or arrays. A member can also consist of a bit field.
• The only operators valid for use with entire structures and unions are the simple assignment (=) and sizeof operators. In particular, structures and unions cannot appear as operands of the equality ( == ), inequality ( != ), or cast operators. The two structures or unions in the assignment must have the same members and member types.
• A structure or a union can be passed by value to functions and returned by value by functions. The argument must have the same type as the function parameter. A structure or union is passed by value just like a scalar variable; that is, the entire structure or union is copied into the corresponding parameter.

  Note When passing structures as arguments, they might or might not terminate on a longword boundary. If they do not, Compaq C aligns the following argument on the next longword boundary.

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

• Within a structure, the members have addresses that increase as the declarators are read left-to-right. That is, the members of a structure all begin at different offsets from the base of the structure. The offset of a particular member corresponds to the order of its declaration; the first member is at offset 0.
  A pointer to a structure points to its first member, so no unnamed holes can reside at the beginning of a structure.
  On OpenVMS VAX systems, nonbit-field structure members are byte-aligned by default. However, the #pragma [no]member_alignment and #pragma pack preprocessor directives are provided to switch from byte preprocessor directive is provided to switch from byte alignment to natural alignment.
  On Alpha systems, nonbit-field structure members are naturally aligned; each successive nonbit-field structure member begins at the next byte boundary that matches the alignment appropriate to its type. For example, a short integer is aligned on a 2-byte boundary and a long integer is aligned on a 4-byte boundary, so there may be unnamed holes in a structure.
  The length of a naturally-aligned structure on a Alpha processors must be a multiple of the greatest alignment requirement of any of its members. For example, a structure containing characters, short integers, and longwords will be a multiple of four in length to match the multiple of four bytes for the longword.
  The ( #pragma [no]member_alignment ) and #pragma pack preprocessor directives are also supported on this platform.
  See your platform-specific Compaq C documentation for specific structure alignment requirements and examples.
• In a union, every member begins at offset 0 from the address of the union. The size of the union in memory is the size of its largest member. The value of only one member can be stored in a union object at a time. When the storage space allocated to the union contains a smaller member, the extra space between the end of the smaller member and the end of the allocated memory remains unaltered. The rules for alignment of union members are the same as for structure members (see your platform-specific Compaq C documentation).
  A pointer to a union member, converted to the proper type, points to the beginning of the union object.
• Several members of a structure can be initialized at once; only the first member of a union can be given an initializer.