Introduction to the C99 Programming Language : Part I - GeeksforGeeks

14 Feb, 2020
C99 is another name of ISO/IEC 9899:1999 standards specification for C that was adopted in 1999. This article mainly concentrates on the new features added in C99 by comparing with the C89 standard. In the development stage of the C99 standard, every element of the C language was re-examined, usage patterns were analyzed, and future demands were anticipated. C’s relationship with C++ provided a backdrop for the entire development process. The resulting C99 standard is a testimonial to the strengths of the original.
Keywords added in C99:inline: C99 adds the keyword inline which is applicable to functions. If we write inline datatype function_name (param) to any function it means that we are specifying the compiler to optimize calls to that function i.e. the function’s code will be expanded inline rather than called.Example:// C program to demonstrate inline keyword  #include <stdio.h>  inline int maximum(int a, int b){    return a > b ? a : b;}  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, maximum(x, y));    return 0;}Note: Some Compilers show undefined reference to maximum(). This inline feature is used rarely as a keyword.The above program is equivalent to the following#include <stdio.h>  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, (x > y ? x : y));    return 0;}Output:Maximum of 5 and 10 is 10
Output:Maximum of 5 and 10 is 10
Inline functions help us to create efficient code by maintaining a structured, function-based approach.restrict: restrict is a type qualifier applicable only for pointers. A pointer qualified by restrict is initially the only means by which the object it points to can be accessed. Access to the object by another pointer can occur only if the second pointer is based on the first.We use restrict qualifier to restrict access to the object. These are primarily used as function parameters or in malloc(). The restrict qualifier never changes the semantics of the program._Bool Datatype: _Bool datatype was added in C99 standard which stores 0 and 1 values. _Bool is an integer type.Note: bool keyword in C++ and _Bool in C are different._Bool is used rarely instead C99 defines a new header file stdbool.h which defines three macros bool, true and false._Complex: C99 adds support for performing operations on complex numbers through _Complex and _Imaginary keywords. These keywords provide better support for numerical programming.Types defined in _Complex:float _Complexdouble _Complexlong double _Complex_Imaginary: As said above, C99 adds support for performing operations on complex numbers through _Complex and _Imaginary keywords. These keywords provide better support for numerical programming.Types defined in _Complex and _Imaginary:float _Imaginarydouble _Imaginarylong double _ImaginaryIn the same way discussed in _Bool datatype, these _Complex and _Imaginary aren’t used frequently. Instead, we use the header-file which consists of in-built macros complex and imaginary macros.Addition of Type Qualifiers: Another important aspect added in C99 is the introduction of long long and unsigned long long type modifiers. A long long int has a range of –(2^63 – 1) to +(2^63 –1). An Unsigned long long int has a minimal range starting from 0 to +(2^64 –1). This long long type allows 64-bit integers to support as a built-in type.Changes in Arrays: C99 added two important features to arrays:Variable Length Arrays: In C89 standard, the array size has to be specified using integer constants at the array declaration and array size is fixed at compile time. In C99 standard, we can declare an array whose dimensions are specified by any integer expressions whose values known at run-time. This is called Variable Length Arrays(VLA).Inclusion of Type Qualifiers: In C99, we can use the keyword static inside the square brackets during array declaration. This is only applied when array is declared in function parameters i.eExample:int fun1(char arr[static 80]){    // code}In the above example arr is always a pointer to an 80-element array i.e arr is guaranteed to point the starting element of the array of chars that contains atleast 80 elements. We can also use the keywords restrict, volatile and const inside the square brackets if that array is declared inside a function parameters. Keyword restrict specifies that the pointer is the sole initial means of access to the object. const states that the pointer always points to the same object. volatile is allowed, but it has no meaning.Example:#include <stdio.h>void fun(int a[static 10]){    for (int i = 0; i < 10; i++) {        a[i] += 1;        printf("%d ", a[i]);    }}  int main(){    int a[] = { 1, 2, 3, 4,                4, 4, 4, 4,                5, 5, 6, 7,                8, 9, 10 };    fun(a);}Output:2 3 4 5 5 5 5 5 6 6
Single Line Comments: Single Line comments aren’t accepted in C89 standard. C99 standard introduces Single Line Comments which are used only when brief remarks are needed. These comments begin with // and runs to the end of the line.Eg:// First Commentint a; // another commentDeclaration of Identifiers:According to the C89 standard, all Identifiers should be declared at the start of the code block. If we need any other identifier at the middle, we can’t declare for that instance or time. We need to declare that at the start. C99 has changed this rule as we can declare identifiers whenever we need in a code.In simple, we can see this as:#include <stdio.h>int main(){    int i;    i = 1;    int j; // this declaration is invalid in C89 standard, but valid in C99 and C++    j = 3;}Output:

Keywords added in C99:inline: C99 adds the keyword inline which is applicable to functions. If we write inline datatype function_name (param) to any function it means that we are specifying the compiler to optimize calls to that function i.e. the function’s code will be expanded inline rather than called.Example:// C program to demonstrate inline keyword  #include <stdio.h>  inline int maximum(int a, int b){    return a > b ? a : b;}  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, maximum(x, y));    return 0;}Note: Some Compilers show undefined reference to maximum(). This inline feature is used rarely as a keyword.The above program is equivalent to the following#include <stdio.h>  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, (x > y ? x : y));    return 0;}Output:Maximum of 5 and 10 is 10
Output:Maximum of 5 and 10 is 10
Inline functions help us to create efficient code by maintaining a structured, function-based approach.restrict: restrict is a type qualifier applicable only for pointers. A pointer qualified by restrict is initially the only means by which the object it points to can be accessed. Access to the object by another pointer can occur only if the second pointer is based on the first.We use restrict qualifier to restrict access to the object. These are primarily used as function parameters or in malloc(). The restrict qualifier never changes the semantics of the program._Bool Datatype: _Bool datatype was added in C99 standard which stores 0 and 1 values. _Bool is an integer type.Note: bool keyword in C++ and _Bool in C are different._Bool is used rarely instead C99 defines a new header file stdbool.h which defines three macros bool, true and false._Complex: C99 adds support for performing operations on complex numbers through _Complex and _Imaginary keywords. These keywords provide better support for numerical programming.Types defined in _Complex:float _Complexdouble _Complexlong double _Complex_Imaginary: As said above, C99 adds support for performing operations on complex numbers through _Complex and _Imaginary keywords. These keywords provide better support for numerical programming.Types defined in _Complex and _Imaginary:float _Imaginarydouble _Imaginarylong double _ImaginaryIn the same way discussed in _Bool datatype, these _Complex and _Imaginary aren’t used frequently. Instead, we use the header-file which consists of in-built macros complex and imaginary macros.
inline: C99 adds the keyword inline which is applicable to functions. If we write inline datatype function_name (param) to any function it means that we are specifying the compiler to optimize calls to that function i.e. the function’s code will be expanded inline rather than called.Example:// C program to demonstrate inline keyword  #include <stdio.h>  inline int maximum(int a, int b){    return a > b ? a : b;}  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, maximum(x, y));    return 0;}Note: Some Compilers show undefined reference to maximum(). This inline feature is used rarely as a keyword.The above program is equivalent to the following#include <stdio.h>  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, (x > y ? x : y));    return 0;}Output:Maximum of 5 and 10 is 10
Output:Maximum of 5 and 10 is 10
Inline functions help us to create efficient code by maintaining a structured, function-based approach.
Example:
// C program to demonstrate inline keyword  #include <stdio.h>  inline int maximum(int a, int b){    return a > b ? a : b;}  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, maximum(x, y));    return 0;}
Note: Some Compilers show undefined reference to maximum(). This inline feature is used rarely as a keyword.
The above program is equivalent to the following
#include <stdio.h>  int main(){    int x = 5, y = 10;    printf("Maximum of %d and %d is %d",           x, y, (x > y ? x : y));    return 0;}
Maximum of 5 and 10 is 10

Maximum of 5 and 10 is 10

Inline functions help us to create efficient code by maintaining a structured, function-based approach.
restrict: restrict is a type qualifier applicable only for pointers. A pointer qualified by restrict is initially the only means by which the object it points to can be accessed. Access to the object by another pointer can occur only if the second pointer is based on the first.We use restrict qualifier to restrict access to the object. These are primarily used as function parameters or in malloc(). The restrict qualifier never changes the semantics of the program.
We use restrict qualifier to restrict access to the object. These are primarily used as function parameters or in malloc(). The restrict qualifier never changes the semantics of the program.
_Bool Datatype: _Bool datatype was added in C99 standard which stores 0 and 1 values. _Bool is an integer type.Note: bool keyword in C++ and _Bool in C are different._Bool is used rarely instead C99 defines a new header file stdbool.h which defines three macros bool, true and false.
Note: bool keyword in C++ and _Bool in C are different.
_Bool is used rarely instead C99 defines a new header file stdbool.h which defines three macros bool, true and false.
_Complex: C99 adds support for performing operations on complex numbers through _Complex and _Imaginary keywords. These keywords provide better support for numerical programming.Types defined in _Complex:float _Complexdouble _Complexlong double _Complex
Types defined in _Complex:
float _Complex
double _Complex
long double _Complex
_Imaginary: As said above, C99 adds support for performing operations on complex numbers through _Complex and _Imaginary keywords. These keywords provide better support for numerical programming.Types defined in _Complex and _Imaginary:float _Imaginarydouble _Imaginarylong double _ImaginaryIn the same way discussed in _Bool datatype, these _Complex and _Imaginary aren’t used frequently. Instead, we use the header-file which consists of in-built macros complex and imaginary macros.
Types defined in _Complex and _Imaginary:
float _Imaginary
double _Imaginary
long double _Imaginary
In the same way discussed in _Bool datatype, these _Complex and _Imaginary aren’t used frequently. Instead, we use the header-file which consists of in-built macros complex and imaginary macros.
Addition of Type Qualifiers: Another important aspect added in C99 is the introduction of long long and unsigned long long type modifiers. A long long int has a range of –(2^63 – 1) to +(2^63 –1). An Unsigned long long int has a minimal range starting from 0 to +(2^64 –1). This long long type allows 64-bit integers to support as a built-in type.
Changes in Arrays: C99 added two important features to arrays:Variable Length Arrays: In C89 standard, the array size has to be specified using integer constants at the array declaration and array size is fixed at compile time. In C99 standard, we can declare an array whose dimensions are specified by any integer expressions whose values known at run-time. This is called Variable Length Arrays(VLA).Inclusion of Type Qualifiers: In C99, we can use the keyword static inside the square brackets during array declaration. This is only applied when array is declared in function parameters i.eExample:int fun1(char arr[static 80]){    // code}In the above example arr is always a pointer to an 80-element array i.e arr is guaranteed to point the starting element of the array of chars that contains atleast 80 elements. We can also use the keywords restrict, volatile and const inside the square brackets if that array is declared inside a function parameters. Keyword restrict specifies that the pointer is the sole initial means of access to the object. const states that the pointer always points to the same object. volatile is allowed, but it has no meaning.Example:#include <stdio.h>void fun(int a[static 10]){    for (int i = 0; i < 10; i++) {        a[i] += 1;        printf("%d ", a[i]);    }}  int main(){    int a[] = { 1, 2, 3, 4,                4, 4, 4, 4,                5, 5, 6, 7,                8, 9, 10 };    fun(a);}Output:2 3 4 5 5 5 5 5 6 6

Variable Length Arrays: In C89 standard, the array size has to be specified using integer constants at the array declaration and array size is fixed at compile time. In C99 standard, we can declare an array whose dimensions are specified by any integer expressions whose values known at run-time. This is called Variable Length Arrays(VLA).
Inclusion of Type Qualifiers: In C99, we can use the keyword static inside the square brackets during array declaration. This is only applied when array is declared in function parameters i.eExample:int fun1(char arr[static 80]){    // code}In the above example arr is always a pointer to an 80-element array i.e arr is guaranteed to point the starting element of the array of chars that contains atleast 80 elements. We can also use the keywords restrict, volatile and const inside the square brackets if that array is declared inside a function parameters. Keyword restrict specifies that the pointer is the sole initial means of access to the object. const states that the pointer always points to the same object. volatile is allowed, but it has no meaning.Example:#include <stdio.h>void fun(int a[static 10]){    for (int i = 0; i < 10; i++) {        a[i] += 1;        printf("%d ", a[i]);    }}  int main(){    int a[] = { 1, 2, 3, 4,                4, 4, 4, 4,                5, 5, 6, 7,                8, 9, 10 };    fun(a);}Output:2 3 4 5 5 5 5 5 6 6

Example:
int fun1(char arr[static 80]){    // code}
In the above example arr is always a pointer to an 80-element array i.e arr is guaranteed to point the starting element of the array of chars that contains atleast 80 elements. We can also use the keywords restrict, volatile and const inside the square brackets if that array is declared inside a function parameters. Keyword restrict specifies that the pointer is the sole initial means of access to the object. const states that the pointer always points to the same object. volatile is allowed, but it has no meaning.
Example:
#include <stdio.h>void fun(int a[static 10]){    for (int i = 0; i < 10; i++) {        a[i] += 1;        printf("%d ", a[i]);    }}  int main(){    int a[] = { 1, 2, 3, 4,                4, 4, 4, 4,                5, 5, 6, 7,                8, 9, 10 };    fun(a);}
2 3 4 5 5 5 5 5 6 6

Single Line Comments: Single Line comments aren’t accepted in C89 standard. C99 standard introduces Single Line Comments which are used only when brief remarks are needed. These comments begin with // and runs to the end of the line.Eg:// First Commentint a; // another comment
Eg:
// First Commentint a; // another comment
Declaration of Identifiers:According to the C89 standard, all Identifiers should be declared at the start of the code block. If we need any other identifier at the middle, we can’t declare for that instance or time. We need to declare that at the start. C99 has changed this rule as we can declare identifiers whenever we need in a code.In simple, we can see this as:#include <stdio.h>int main(){    int i;    i = 1;    int j; // this declaration is invalid in C89 standard, but valid in C99 and C++    j = 3;}Output:

In simple, we can see this as:
#include <stdio.h>int main(){    int i;    i = 1;    int j; // this declaration is invalid in C89 standard, but valid in C99 and C++    j = 3;}


C Language
Programming Language
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
TCP Server-Client implementation in C
Multithreading in C
Exception Handling in C++
'this' pointer in C++
Arrow operator -> in C/C++ with Examples
Arrow operator -> in C/C++ with Examples
Structures in C++
Differences between Procedural and Object Oriented Programming
Top 10 Programming Languages to Learn in 2022
Decorators with parameters in Python