Type qualifiers / modifiers express the way in which a variable is accessed or where a variable is stored in the memory by keeping the meaning or interpretation of the variable same. In a way, type qualifiers add more refinement to variables.

const Qualifier

Use the const type qualifier to qualify an object whose value cannot be changed. Objects qualified by the const keyword cannot be modified. This means that an object declared as const cannot serve as the operand in an operation that changes its value; for example, the ++ and -- operators are not allowed on objects qualified with const . Using the const qualifier on an object protects it from the side effects caused by operations that alter storage.

Declaration of const

const int x = 44;   /*  const qualification of int type  --
                        the value of x cannot be modified  */
const int *z;       /*  Pointer to a constant integer    --
                        The value in the location pointed
                        to by z cannot be modified         */
int * const ptr;    /*  A constant pointer -- a pointer
                        which will always point to the
                        same location                      */
const int *const p; /*  A constant pointer to a constant
                        integer -- neither the pointer or
                        the integer can be modified        */
const const int y;  /*  Illegal - redundant use of const   */

Rules of using const type qualifier

• The const qualifier can be used to qualify any data type, including a single member of a structure or union.
• If const is specified when declaring an aggregate type, all members of the aggregate type are treated as objects qualified with const . When const is used to qualify a member of an aggregate type, only that member is qualified. For example:

const struct employee {
    char *name;
    int   birthdate; /* name, birthdate, job_code, and salary are */
    int   job_code;  /* treated as though declared with const.    */
    float salary;
    } a, b;          /* All members of a and b are const-qualified*/
struct employee2 {
    char *name;
    const int birthdate;  /*  Only this member is qualified    */
    int job_code;
    float salary;
    } c, d;

All members in the first structure are qualified with const . If the tag employee is used to specify another structure later in the program, the const qualifier does not apply to the new structure's members unless explicitly specified.

• The const qualifier can be specified with the volatile qualifier. This is useful, for example, in a declaration of a data object that is immutable by the source process but can be changed by other processes, or as a model of a memory-mapped input port such as a real-time clock.
• The address of a non-const object can be assigned to a pointer to a const object (with an explicit const specifier), but that pointer cannot be used to alter the value of the object. For example:

const int i = 0;
int j = 1;
const int *p = &i; /* Explicit const specifier required      */
int *q = &j;
*p = 1;            /* Error -- attempt to modify a const-
                      qualified object through a pointer      */
*q = 1;            /* OK                                     */

• Attempting to modify a const object using a pointer to a non-const qualified type causes unpredictable behavior.

valatile Qualifier

The type qualifier volatile means that the value of the variable marked volatile may be changed in other ways that are not specified by the program. The variables that are volatile change usually due to some external factors and not necessarily because of the program. In other words, they are volatile in nature.

Declaration of volatile 

volatile char keyboard_ch;  /* a volatile variable */

Rules of using volatile type qualifier

• The volatile qualifier can be used to qualify any data type, including a single member of a structure or union
• Redundant use of the volatile keyword elicits a warning message.

For Example

volatile volatile int x;

• When volatile is used with an aggregate type declaration, all members of the aggregate type are qualified with volatile . When volatile is used to qualify a member of an aggregate type, only that member is qualified. 

For Example

volatile struct employee {
    char *name;
    int   birthdate; /* name, birthdate, job_code, and salary are */
    int   job_code;  /* treated as though declared with volatile. */
    float salary;
    } a,b;          /*  All members of a and b are volatile-qualified  */
struct employee2 {
    char *name;
    volatile int birthdate;  /*  Only this member is qualified    */
    int job_code;
    float salary;
    } c, d;

If the tag employee is used to specify another structure later in the program, the volatile qualifier does not apply to the new structure's members unless explicitly specified.

• The const qualifier can be used with the volatile qualifier. This is useful, for example, in a declaration of a data object that is immutable by the source process but can be changed by other processes, or as a model of a memory-mapped input port such as a real-time clock.
• The address of a non-volatile object can be assigned to a pointer that points to a volatile object.

For Example

const int *intptr;
volatile int x;
intptr = &x;

Likewise, the address of a volatile object can be assigned to a pointer that points to a non-volatile object