Type qualifiers

A type qualifier is used to refine the declaration of a variable, a function, and parameters, by specifying whether:

• The value of an object can be changed
• The value of an object must always be read from memory rather than from a register
• More than one pointer can access a modifiable memory address

ILE C/C++ recognizes the following type qualifiers:

• __align
• const
• restrict
• volatile

When the const and volatile keywords are used with pointers, the placement of the qualifier is critical in determining whether it is the pointer itself that is to be qualified, or the object to which the pointer points. For a pointer that you want to qualify as volatile or const, you must put the keyword between the * and the identifier. For example:

int * volatile x;        /* x is a volatile pointer to an int */
int * const y = &z;      /* y is a const pointer to the int variable z */

For a pointer to a volatile or const data object, the type specifier and qualifier can be in any order, provided that the qualifier does not follow the * operator. For example:

volatile int *x;         /* x is a pointer to a volatile int
   or                                                         */
int volatile *x;         /* x is a pointer to a volatile int  */

const int *y;            /* y is a pointer to a const int
   or                                                         */
int const *y;            /* y is a pointer to a const int     */

The following examples contrast the semantics of these declarations:

A type qualifier cannot apply to user-defined types, but only to objects created from a user-defined type. Therefore, the following declaration is illegal:

volatile struct omega {
   int limit;
   char code;
};

However, if a variable or variables are declared within the same definition of the type, a type qualifier can be applied to the variable or variables by placing at the beginning of the statement or before the variable declarator or declarators. Therefore:

volatile struct omega {
   int limit;
   char code;
} group;

provides the same storage as:

struct omega {
   int limit;
   char code;
} volatile group;

In both examples, the volatile qualifier only applies to the structure variable group.