HP 3000 Manuals HP 3000 Manuals
Type Qualifiers
Syntax
type-qualifier ::= const
volatile
Description
This section describes the type qualifiers--volatile and const.
The volatile type qualifier directs the compiler not to perform certain
optimizations on an object because that object can have its value altered
in ways beyond the control of the compiler.
Specifically, when an object's declaration includes the volatile type
qualifier, optimizations that would delay any references to (or
modifications of) the object will not occur across sequence points. A
sequence point is a point in the execution process when the evaluation of
an expression is complete, and all side-effects of previous evaluations
have occurred.
The volatile type qualifier is useful for controlling access to
memory-mapped device registers, as well as for providing reliable access
to memory locations used by asynchronous processes.
The const type qualifier informs the compiler that the object will not be
modified, thereby increasing the optimization opportunities available to
the compiler.
An assignment cannot be made to a constant pointer, but an assignment can
be made to the object to which it points. An assignment can be made to a
pointer to constant data, but not to the object to which it points. In
the case of a constant pointer to constant data, an assignment cannot be
made to either the pointer, or the object to which it points.
Type qualifiers may be used alone (as the sole declaration-specifier), or
in conjunction with type specifiers, including struct, union, enum, and
typedef. Type qualifiers may also be used in conjunction with
storage-class specifiers.
Table 3-2 illustrates various declarations using the const and volatile
type qualifiers.
Table 3-2. Declarations using const and volatile
---------------------------------------------------------------------------------------------
| | |
| Declaration | Meaning |
| | |
---------------------------------------------------------------------------------------------
| | |
| volatile int vol_int; | Declares a volatile int variable. |
| | |
| const int *ptr_to_const_int; | Both declare a variable pointer to a |
| int const *ptr_to_const_int; | constant int. |
| | |
| int *const const_ptr_to_int; | Declares a constant pointer to a variable |
| | int. |
| | |
| int *volatile vpi, *pi; | Declares two pointers: vpi is a volatile |
| | pointer to an int; pi is a pointer to an |
| | int. |
| | |
| int const *volatile vpci; | Declares a volatile pointer to a constant |
| | int. |
| | |
| const *pci; | Declares a pointer to a constant int. |
| | Since no type specifier was given, it |
| | defaults to int. |
| | |
---------------------------------------------------------------------------------------------
When a type qualifier is used with a variable typed by a typedef name,
the qualifier is applied without regard to the contents of the typedef.
For example,
typedef int *t_ptr_to_int;
volatile t_ptr_to_int vol_ptr_to_int;
In the example above, the type of vol_ptr_to_int is volatile
t_ptr_to_int, which becomes volatile pointer to int. If the type
t_ptr_to_int were substituted directly in the declaration,
volatile int *ptr_to_vol_int;
the type would be pointer to volatile int.
Type qualifiers apply to objects, not to types. For example,
typedef int *t;
const t *volatile p;
In the example above, p is a volatile pointer to a const pointer to int.
volatile applies to the object p, while const applies to the object
pointed to by p. The declaration of p can also be written as follows:
t const *volatile p;
If an aggregate variable such as a structure is declared volatile, all
members of the aggregate are also volatile.
If a pointer to a volatile object is converted to a pointer to a
non-volatile type, and the object is referenced by the converted pointer,
the behavior is undefined.