Type qualifiers in C

Type qualifiers in C: In the C programming language, type qualifiers are the keywords that prepend to the variables to change their accessibility, i.e., we can tell that the type qualifiers are used to change the properties of variables. In other words, the qualifiers are the keywords that are applied to the data types or the type modifiers in C.

Types of type qualifiers

There are three types of type qualifier variables in the C programming language.

• const
• volatile
• restrict

Type qualifiers are basically the keywords that are used to modify the properties of the existing variables.

1. Const qualifier

• The const qualifier is used to declare a variable to be read only (constant), the value may not be changed, and it can be declared using the keyword const.
• This qualifier will help to prevent accidental changes in the values.
• In order to declare a const qualifier, include the keyword const before or after any data type.

Syntax

The syntax for declaring a const qualifier is:

 const data-type constant-name = value;
 Or
 data-type const constant-name = value; 

Use the const type qualifier to qualify an object whose value cannot be changed at any given time.

The objects qualified by the ‘const’ keyword cannot be modified, i.e., an object declared as a ‘const’ cannot serve as an operand in an operation that changes its value in further operations.

 int const *p_ci;      /* Pointer to constant int*/
 int const (*p_ci);   /* Pointer to constant int*/
 int *const cp_i;     /* Constant pointer to int*/
 int (*const cp_i);   /*Constant pointer to int*/
 int volatile vint;     /* Volatile integer*/ 

E.g.: 

 #include <stdio.h>
 #include <conio.h>
 #include <string.h>
 int main()
 {
 const float pi = 3.14;
 printf (“The value of pi is = %f \n”, pi);
 return 0;
 } 

Output

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

2. Volatile qualifier

• A volatile qualifier is used to declare a variable that can be changed at any point of time and explicitly, i.e., it always tells the compiler that the variable’s value may change at any time.
  • It will be useful for embedding programming in order to keep the updated value that can be changed from various interrupts.
  • To declare a volatile variable, the keyword ‘volatile’ is used.
  • In order to declare a volatile variable, include the keyword volatile before or after the data type.

Syntax

The syntax to declare ta volatile variable is as follows:

 volatile data-type variable-name;
 Or
  data-type volatile variable-name; 

An object without the volatile specifier will not tell the compiler to perform the optimizations. It indicates that the compiler can apply any optimizations depending on the program context and compiler optimization levels.

E.g.:

 #include <stdio.h>
 #include <conio.h>
 #include <string.h>
 int x = 0;
 volatile int y = 0;
 int main()
 {
 y = 0; /* the compiler optimizes the code and else will be optimized
 because the variable(x) will never be other than 0*/
 if (x == 0)
 {
 printf (“The value of the variable x is zero \n”);
 }
 else
 {
 printf (“The value of the variable x is not zero \n”);
 }
 if (x == 0)
 {
 printf (“The value of the variable y is zero \n”);
 }
 else
 {
 printf (“The value of the variable y is not zero \n”);
 }
 return 0;
 } 

Output

Optimizations that are defeated by using the volatile qualifier and can be categorized as follows:

• Optimizations alter an object's duration, such as cases where referencing to an object is shifted or moved to another part of the program.
• Optimizations alter an object's locality, such as cases where a variable serving as a loop counter can be stored in a register to save the cost of doing any memory reference.
• Optimizations alter an object's existence, such as loop induction to eliminate the variable reference.

3. Restrict qualifier

• The new type of qualifier introduced to C99 can be applied to pointer declarations.
• It qualifies the pointer, not what it points at.
• It is an optimization hint that no other pointer in the present scope refers to the exact location.
• It acts as a contract between a developer and a compiler. If you do alias a pointer marked with restrict, then the result is undefined.

E.g.:

 #include <stdio.h>
 void my_function(int* x, int* y, int* restrict z) {
    *x += *z;
    *y += *z;
 }
 main(void) {
    int x = 10, y = 20, z = 30;
    my_function(&x, &y, &z);
    printf("%d %d %d", x, y, z);
 } 

Output

Marking union members as restrict will tell the compiler that only some of the options can be accessed in scope, allowing the compiler to optimize the access to members.