3.2 Integral Types

In C, an integral type can declare:

• Integer values, signed or unsigned
• Boolean values, where 0 is equivalent to false and any nonzero number is equivalent to true
• Characters, which are automatically converted to an integer value by the compiler
• Members of an enumerated type, which are interpreted as an integer by the compiler
• Bit fields

The integral types are:

• char, signed char, unsigned char---8 bits
• short int, signed short int, and unsigned short int---16 bits
• _Bool---1 byte
• int, signed int, unsigned int---32 bits
• long int, signed long int, and unsigned long int---32 bits (OPENVMS)
• long int, signed long int, and unsigned long int---64 bits (TRU64 UNIX)
• signed long long int (ALPHA, I64) and unsigned long long int (ALPHA, I64)---64 bits
• signed __int64 (ALPHA, I64) and unsigned __int64 (ALPHA, I64)---64 bits
• enum---32 bits

3.2.1 Non-Character Types

For HP C on OpenVMS systems, storage for int and long is identical. Similarly, storage of signed int and signed long is identical, and storage for unsigned int and unsigned long is identical.

For HP C on Tru64 UNIX systems, storage for the int data types is 32 bits, while storage for the long int data types is 64 bits.

The 64-bit integral types signed long long int and unsigned long long int, and their equivalents signed __int64 and unsigned __int64 are provided on Alpha and Itanium processors only. Note: the __int64 and long long int data types (both signed and unsigned) can be used interchangeably, except for use with pointer operations, in which case the pointer types must be identical:

__int64 *p1; __int64 *p2; long long int *p3; . . . p1 = p2; // valid p1 = p3; // invalid

For each of the signed integral types, there is a corresponding unsigned integral type that uses the same amount of storage. The unsigned keyword with the integral type modifies the way the integer value is interpreted, which allows the storage of a larger range of positive values. When using the unsigned keyword, the bits are interpreted differently to allow for the increased positive range with the unsigned type (at the expense of the negative range of values). For example:

signed short int x = 45000; /* ERROR -- value too large for short int */ unsigned short int y = 45000;/* This value is OK */

The range of values for the signed short int type is - 32,768 to 32,767. The range of values for the unsigned short int type is 0 to 65,535.

A computation involving unsigned operands can never overflow, because any result outside the range of the unsigned type is reduced to fit the type by the rules of modulus arithmetic. If the result cannot be represented by the resulting integer type, the result is reduced modulo the number that is one greater than the largest value that can be represented by the resulting unsigned integer type. This means that the low-order bits are kept, and the high-order bits of the mathematical result that do not fit in the type of the result are discarded. For example:

unsigned short int z = (99 * 99999); /* Value of y after evaluation is 3965 */

HP C treats the plain char type as signed by default for compatibility with VAX C and many other C compilers. However, a command-line option can control this, and a predefined macro can be tested to determine the setting of the option in a given compilation. On Alpha systems, unsigned char might offer some performance advantage for character-intensive processing.

An unsigned integer of n bits is always interpreted in straight unsigned binary notation, with possible values ranging from 0 to 2 ⁿ-1 .

The C99-specified _Bool data type is available in all modes of the compiler except VAX C, common, and strict ANSI89 modes. A _Bool object occupies a single byte of storage and is treated as an unsigned integer, but its value can be only 0 or 1.

3.2.2 Character Types

Character types are declared with the keyword char and are integral types. Using char objects for nonintegral operations is not recommended, as the results are likely to be nonportable. An object declared as a char type can always store the largest member of the source character set.

Valid character types are:

• char
• signed char
• unsigned char
• wchar_t

The wide character type wchar_t is provided to represent characters not included in the ASCII character set. The wchar_t type is defined using the typedef keyword in the <stddef.h> header file. Wide characters used in constants or strings must be preceded with an L. For example:

#include <stddef.h> wchar_t a[6] = L"Hello";

All char objects are stored in 8 bits. All wchar_t objects are stored as unsigned int objects in 32 bits. The value of a given character is determined by the character set being used. In this text, the ASCII character set is used in all examples. See Appendix C for a complete list of ASCII equivalents, in decimal, octal, and hexadecimal radixes.

To aid portability, declare char objects that will be used in arithmetic as signed char or unsigned char. For example:

signed char letter; unsigned char symbol_1, symbol_2; signed char alpha = 'A'; /* alpha is declared and initialized as 'A' */

Strings are arrays of characters terminated by the null character (\0). Section 1.9.3 has more information on the syntactic rules of using strings; Chapter 4 has information on declaring string literals.

3.3 Floating-Point Types

The floating-point types are:

• float---32 bits
• double---64 bits
• long double (OPENVMS ALPHA)---128 bits by default, with the option for 64 bits
• long double (TRU64 UNIX)---64 bits in current versions of Tru64 UNIX
• long double (VAX)---64 bits
• float _Complex (ALPHA, I64)
• double _Complex (ALPHA, I64)
• long double _Complex (ALPHA, I64)

Use the floating-point types for variables, constants, and function return values with fractional parts, or where the value exceeds the storage range available with the integral types. The following examples show sample floating-point type declarations (and initializations):

float x = 35.69; double y = .0001; double z = 77.0e+10; float Q = 99.9e+99; /* Exceeds allowable range */

3.3.1 Complex Type (ALPHA, I64)

The C99 standard introduces a built-in complex data type similar to the Fortran type, in all three precisions (float _Complex, double _Complex, and long double _Complex). It also has an associated header file, <complex.h> The <complex.h> header file defines a macro spelled "complex", intended to be the preferred way to refer to the types. (See Section 9.2).

A complex type has the same representation and alignment requirements as an array type containing exactly two elements of the corresponding real type; the first element is equal to the real part, and the second element to the imaginary part, of the complex number.

The type is similar to the Fortran type in its use. There is no special syntax for constants; instead there is a new keyword _Complex_I, which has a complex value whose real part is zero and whose imaginary part is 1.0. The header file defines a macro I that expands to _Complex_I, and so a complex constant with equal real and imaginary parts of 2.0 would be written as 2.0 + 2.0*I.

There are some known issues with complex types on HP C:

• The complex data types are not available when using the /FLOAT=D_FLOAT command-line option. This is a permanent restriction.
• The complex types and functions other than long double complex are available on versions of OpenVMS prior to Version 7.3. The long double complex type is available with OpenVMS Version 7.3.
• Initialized declarations of long double complex variables cause a compiler assertion failure when generating a machine-code listing.
• Functions named cabs, cabsf, and cabsl have traditionally been declared in <math.h> using a struct representation to hold two floating values. This is not compatible with the calling standard for passing complex values. To access working cabs functions, you must include <complex.h> before you include <math.h>.

3.3.2 Imaginary Type (ALPHA, I64)

The C99 standard reserves the keyword _Imaginary for use as a type-specifier in conjunction with an experimental/optional feature called a "pure imaginary" type, specified in informative Annex G. In HP C, use of the _Imaginary keyword produces a warning, which is resolved by treating it as an ordinary identifier.

3.4 Derived Types

There are five derived types in C:

• Function types
• Pointer types
• Array types
• Structure types
• Union types

The following sections describe these derived types.

A derived type is formed by using one or more basic types in combination. Using derived types, an infinite variety of new types can be formed. The array and structure types are collectively called the aggregate types. Note that the aggregate types do not include union types, but a union may contain an aggregate member.

3.4.1 Function Type

A function type describes a function that returns a value of a specified type. If the function returns no value, it should be declared as "function returning void" as follows:

void function1 ();

In the following example, the data type for the function is "function returning int":

int uppercase(int lc) { int uc = lc + 0X20; return uc; }

Chapter 4 discusses declarations in general. Chapter 5 covers functions specifically, including their declarations, parameters, and argument passing.

3.4.2 Pointer Type

A pointer type describes a value that represents the address of an object of a stated type. A pointer is stored as an integral value that references the address of the target object. Pointer types are derived from other types, called the referenced type of the pointer. For example:

int *p; /* p is a pointer to an int type */ double *q(); /* q is a function returning a pointer to an object of type double */ int (*r)[5]; /* r is a pointer to an array of five elements */ /* (r holds the address to the first element of the array) */ const char s[6]; /* s is a const-qualified array of 6 elements */

The pointer itself can have any storage class, but the object addressed by the pointer cannot have the register storage class or be a bit field. Pointers to qualified or unqualified versions of compatible types have the same representation and alignment requirements as the target type. Pointers to other types need not have the same representation or alignment requirements.

The construction void * designates a generic "pointer to void" type. The void * construction can be used to point to an object of any type, and it is most useful when a pointer is needed to point to the address of objects with different or unknown types (such as in a function prototype). A pointer to void can also be converted to or from a pointer of any other type, and has the same representation and alignment requirements as a pointer to a character type.

A pointer to the address 0 (zero) is called a null pointer. Null pointers are often used to indicate that no more members of a list exist (for example, when using pointers to show the next member of the list). Dereferencing a null pointer with the * or subscripting operators leads to unpredictable and usually very unfavorable results.

See Chapter 4 for details on the syntax of pointer declarations.

3.4.3 Array Type

An array type can be formed from any valid completed type. Completion of an array type requires that the number and type of array members be explicitly or implicitly specified. The member types can be completed in the same or a different compilation unit. Arrays cannot be of void or function type, since the void type cannot be completed and function types are not object types requiring storage.

Typically, arrays are used to perform operations on some homogeneous set of values. The size of the array type is determined by the data type of the array and the number of elements in the array. Each element in an array has the same type. For example, the following definition creates an array of four characters:

char x[] = "Hi!" /* Declaring an array x */;

Each of the elements has the size of a char object, 8 bits. The size of the array is determined by its initialization; in the previous example, the array has three explicit elements plus one null character. Four elements of 8 bits each results in an array with a size of 32 bits.

An array is allocated contiguously in memory, and cannot be empty (that is, have no members). An array can have only one dimension. To create an array of "two dimensions," declare an array of arrays, and so on.

It is possible to declare an array of unknown size; this sort of declaration is called an incomplete array declaration, because the size is not specified. The following example shows an incomplete declaration:

int x[];

The size of an array declared in this manner must be specified elsewhere in the program. (See Section 4.7 for more information on declaring incomplete arrays and initializing arrays.)

Character strings (string literals) are stored in the form of an array of char or wchar_t type, and are terminated by the null character (\0).

An array in C has only one dimension. An array of arrays can be declared, however, to create a multidimensional array. The elements of these arrays are stored in increasing addresses so that the rightmost subscript varies most rapidly. This is called row-major order, and is analogous to a car's odometer. For example, in an array of two arrays declared as int a[2][3]; the elements are stored in this order:

a[0][0], a[0][1], a[0][2], a[1][0], a[1][1], a[1][2]

3.4.4 Structure Type

A structure type is a sequentially allocated nonempty set of objects, called members. Structures let you group heterogeneous data. They are much like records in Pascal. Unlike arrays, the elements of a structure need not be of the same data type. Also, elements of a structure are accessed by name, not by subscript. The following example declares a structure employee, with two structure variables (ed and mary) of the structure type employee:

struct employee { char name[30]; int age; int empnumber; }; struct employee ed, mary;

Structure members can have any type except an incomplete type, such as the void type or a function type. Structures can contain pointers to objects of their own type, but they cannot contain an object of their own type as a member; such an object would have an incomplete type. For example:

/* This is invalid. */ struct employee { char name[30]; struct employee div1; /* This is invalid. */ int *f(); /* This is also invalid. */ };

The following example, however, is valid:

struct employee { char name[30]; struct employee *div1;/* Member can contain pointer to employee structure. */ int (*f)(); /* Pointer to a function returning int */ };

The name of a declared structure member must be unique within the structure, but it can be used in another nested or unnested structure or name spaces to refer to a different object. For example:

struct { int a; struct { int a; /* This 'a' refers to a different object than the previous 'a' */ } nested; };

As an extension, the relaxed modes of HP C allow a strucure or union to declare nested structure or union members without specifying names for the members - called anonymous members. The effect is as if the names of the members of the anonymous nested structure or union were declared directly within the containing structure or union, rather than being nested. Therefore, in the preceding example, if the identifier nested were omitted from the inner struct declaration, there would be an error because the member a in the inner structure would conflict with the member a in the containing structure. This is similar to the anonymous union feature of the C++ language (except that it is permitted for both structures and unions), and to the variant_struct and variant_union features unique to VAX C.

Chapter 4 contains more examples on structures and their declarations.

The compiler assigns storage for structure members in the order of member declaration, with increasing memory addresses for subsequent members. The first member always begins at the starting address of the structure itself. Subsequent members are aligned per the alignment unit, which may differ depending on the member sizes in the structure. A structure may contain padding (unused bits) so that members of an array of such structures are properly aligned, and the size of the structure is the amount of storage necessary for all members plus any padded space needed to meet alignment requirements. See your system's HP C documentation for platform-specific information about structure alignment and representation.

A pragma is available to change the alignment of a structure on one platform to match that of structures on other platforms. See Section B.29 for more information on this pragma.

3.4.5 Union Type

A union type can store objects of different types at the same location in memory. The different union members can occupy the same location at different times in the program. The declaration of a union includes all members of the union, and lists the possible object types the union can hold. The union can hold any one member at a time---subsequent assignments of other members to the union overwrite the existing object in the same storage area.

Unions can be named with any valid identifier. An empty union cannot be declared, nor can a union contain an instance of itself. A member of a union cannot have a void, function, or incomplete type. Unions can contain pointers to unions of their type.

Another way to look at a union is as a single object that can represent objects of different types at different times. Unions let you use objects whose type and size can change as the program progresses, without using machine-dependent constructions. Some other languages call this concept a variant record.

The syntax for defining unions is very similar to that for structures. Each union type definition creates a unique type. Names of union members must be unique within the union, but they can be duplicated in other nested or unnested unions or name spaces. For example:

union { int a; union foo { int a; /* This 'a' refers to a different object than the previous 'a' */ } nested; };

Note that as an extension, relaxed modes of HP C permit anonymous union members as in the C++ language.

The size of a union is the amount of storage necessary for its largest member, plus any padding needed to meet alignment requirements.

Once a union is defined, a value can be assigned to any of the objects declared in the union declaration. For example:

union name { double dvalue; struct x { int value1; int value2; }; float fvalue; } alberta; alberta.dvalue = 3.141596; /* Assigns the value of pi to the union object */

Here, alberta can hold a double, struct, or float value. The programmer has responsibility for tracking the current type of object contained in the union. An assignment expression can be used to change the type of value held in the union.

Undefined behavior results when a union is used to store a value of one type, and then the value is accessed through another type. For example:

/* Assume that `node' is a typedef_name for objects for which information has been entered into a hash table; `hash_entry' is a structure describing an entry in the hash table. The member `hash_value' is a pointer to the relevant `node'. */ typedef struct hash_entry { struct hash_entry *next_hash_entry; node *hash_value; /* ... other information may be present ... */ } hash_entry; extern hash_entry *hash_table [512]; /* `hash_pointer' is a union whose members are a pointer to a `node' and a structure containing three bit fields that overlay the pointer value. Only the second bit field is being used, to extract a value from the middle of the pointer to be used as an index into the hash table. Note that nine bits gives a range of values from 0 to 511; hence, the size of `hash_table' above. */ typedef union { node *node_pointer; struct { unsigned : 4; unsigned index : 9; unsigned :19; } bits; } hash_pointer;