Enumeration || Preprocessor || Library Functions in C

Now before we conclude this C Programming Tutorial, we will discuss the last but few of the important most additional concepts used in C.

This will include Enumeration, the Preprocessor, and Standard library functions in C.

Now let’s move on further and discuss the Enumeration concept used in C.

Enumeration in C

An enumeration may be a set of named integer constants. Enumerations are common in lifestyle.
For example, an enumeration of the coins utilized is penny, nickel, dime, quarter, half-dollar, dollar.

Enumerations are defined as very similar to structures; the keyword enum signals the beginning of an enumeration type.

The general form for enumerations is:

enum tag { enumeration list } variable_list;

  • Here, both the tag and therefore the variable list are optional.
  • But a minimum of one must be present.


enum coin {penny, nickel, dime, quarter, half_dollar, dollar};

  • Here, the above code fragment defines an enumeration called coin.

enum coin money;

  • Here, money may be a variable of type coin.
  • The enumeration tag name is often wont to declare variables of its type.


money = dime;
if(money==quarter) printf(''Money may be a quarter.\n");
printf("%d %d", penny, dime);

The output of the above code fragment is going to be 0 2.

We can specify the worth of 1 or more of the symbols by using an initializer by following the symbol with an equal sign and an integer value. Symbols that appear after an initializer are assigned values greater than the preceding value.


enum coin {penny, nickel, dime, quarter=100, half_dollar, dollar};

The values evaluated by the above fragment of the code will be: penny = 0, nickel = 1, dime = 2, quarter = 100, half_dollar = 101, and dollar = 102 respectively.

Below is an example to demonstrate the use of enumeration in a program.

Example: Program to print integer constant value using the enumeration concept.


#include <stdio.h>
int main()
    enum TEAM { CSK = 11, MI = 25, RCB = 15, KKR = 22, RR = 30, SH = 32 };
    printf("   \tIPL POINTS TABLE \n");
    printf("   TEAM \t\t   POINTS \n");
    printf("Chennai Super Kings:         %2d\n", CSK);
    printf("Kolkata Knight Riders:       %2d\n", KKR);
    printf("Mumbai Indians:              %2d\n", MI);
    printf("Royal Challengers Bangalore: %2d\n", RCB);
    printf("Rajasthan Royals:            %2d\n", RR);
    printf("Sunrisers Hyderabad:         %2d\n", SH);
    return 0;


   TEAM                    POINTS 
Chennai Super Kings:         11
Kolkata Knight Riders:       22
Mumbai Indians:              25
Royal Challengers Bangalore: 15
Rajasthan Royals:            30
Sunrisers Hyderabad:         32

Important note:

  • The key point to know about an enumeration is that each of the symbols stands for an integer value.
  • As such, they will be used anywhere that an integer is often used.
  • Each symbol is given a worth one greater than the symbol that precedes it.
  • The worth of the primary enumeration symbol is 0.

Preprocessor in C

The preprocessor provides access to many features that are not available in other high-level languages, which makes C a unique and flexible language. Using this tool, a developer can write programs that are easy to read, easy to modify, portable, and more efficient.

What is Preprocessor?

The preprocessor is a program that processes the source code before it is passed through the compiler. It operates through the control of the preprocessor command line or directives.

The preprocessor directive is placed in a source program before the mainline. The source code is examined by the preprocessor before it is passed through the compiler. If there are any actions to be taken (as per the directives), then the source code is handed over to the compiler.

Preprocessor directives have special syntax rules that are distinct from other syntaxes that we have seen in C till now.

  • They begin from symbol #
  • They don’t require a semicolon at the end.
  •  E.g.- #define and #include

Preprocessor directives can be divided into three categories:

  1. Macro Substitution Directives
  2. File Inclusion Directives
  3. Compiler Directives


Defined a macro substitution

Undefines a macro


Specifies the files to be included

Test for a micro definition


Specifies the end of #if

Tests whether a macro is not defined


Test a compile-time condition

Specifies alternatives when #if fails

What are Macro Substitution Directives?

Macro Substitution is a process where an identifier in a program is replaced by a predefined string composed of one or more tokens. The preprocessor does this task under the direction #define statement. This statement is known as a macro definition.

The general form of this statement is: #define identifier string

When this statement is included at the beginning, then the preprocessor replaces every occurrence of the identifier in the source code by the string. The keyword #define is written in the same way followed by the identifier and a string with at least one blank space between them.

Simple Macro Substitution Directives

It is the most used macro to define constants.






#define SUBJECTS



PI 3.141592
#define CAPITAL


  • It is a convention to write all macros in capitals to identify them as symbolic constants.
  • However, a macro inside a string does not get replaced.
  • A macro definition can include more than a simple constant value.

Valid definition: #define AREA 5 * 12.46

In the usage of expression for replacement, we should prevent an unexpected order of evaluation.


ratio = D/A;

#define D 45 – 22

#define A 78 + 32

The result of the preprocessor’s substitution for D and A is:

ratio = 45-22/78+32;

Macros with arguments Substitution Directives

We can define a more complex and more useful form of replacements.

It’s form is: #define identifier(f1, f2, . . .fn) string

  • Here, there is no space between the macro identifier and the left parentheses.
  • The identifier f1, f2, . . .fn are the normal macro arguments that are analogous to the formal arguments in a function definition.
  • The subsequent occurrence of a macro with an argument is known as a macro call (similar to a function call).
  • When a macro is called, the preprocessor substitutes the string, replacing the formal parameters with the actual parameter.


#define CUBE(x) (x*x*x)

What are File Inclusion Directives?

An external file containing functions or macro definitions can be included as a part of a program so that we don’t have to write those functions or macro definitions.

It can be performed using the preprocessor directive: #include “filename”

  • Here, the filename is the name of the file containing the required definitions or functions.
  • The preprocessor inserts the entire content of the filename into the source code of the program.
  • When the filename is included within the double quotation marks, the search for the file is made first in the current directory and then in the standard directories.

What are Compiler Directives?

There could be a situation where we have to develop a different program to suit the needs of the different situations. We can also develop a comprehensive program that includes all optional codes and then directs the compiler to skip over certain parts of the source code when they are not required. In C preprocessor, a feature called conditional compilation, which can be used to ‘switch’ on or off a particular line or group of lines of the program.

Type 1

This type handles the condition definition of a macro. We must ensure that the macro TEST is always defined, irrespective of whether it has been defined or not.


#include “DEFINE.H”

#ifndef TEST

#define TEST1


. . . 
. . .

Type 2

This type makes the program portable.

We can perform this operation by following the given pattern:

. . .
. . .
   . . .
   . . .
#ifdef IBM_PC
   . . .
   . . .
   . . .
   . . .
   . . .
   . . .
   . . .
   . . .

If we have to run the program on  IBM PC, we must include the directive: #define IBM_PC

Type 3

This type is the same as type 2 and hence the control directives have the following form:

#ifdef ABC
      group-A lines
      group-B lines
  • Here, group-A lines are included if the customer ABC is defined.
  • Otherwise, group-B lines are included.
Type 4

This type is used to handle the debugging and testing to detect the errors in the program. We can use debugging statements to isolate or correct errors, which can later be deleted or we could make them inactive.

. . .
. . .
#ifdef TEST
   printf("Array elements\n");
   for(i = 0; i < m; i++)
      printf("x[%d] = %d\n", i, x[i]);
. . .
. . .
#ifdef TEST
. . .
  • Here, the statements between directives #ifdef and #endif are only included if the macro TEST is defined.
  • After, it is okay, delete or undefine the TEST. This makes all the #ifdef TEST conditions false and hence all the debugging statements are left out.

Library Functions in C

In C programming language, each of the content and form of the C standard library is defined. That is, the C library specifies a group of functions that every standard compiler should support.

However, a compiler is absolved to offer further functions not such by the standard. (And, indeed, most compilers do.) as an example, it’s common for a compiler to possess graphics functions, mouse-handler routines, and also the like, despite the fact that none of those is outlined by standard C. As long as you’ll not be porting your programs to a brand new atmosphere, you’ll use these nonstandard functions with none negative consequences.

However, if your code should be moveable, the operation of those functions should be restricted. From a sensible purpose of reading, just about all nontrivial C programs can create use of nonstandard functions, therefore you must not essentially retreat from their use simply because they’re not a part of the standard function library.

The use of header files which contains the commonly used functions in C is highlighted in the points given below:

  • Each function included within the C standard library features a header related to it.
  • The headers that are related to the functions that we use in your programs are included by using #include.
  • The headers perform 2 necessary jobs. First, several functions within the standard library work with their own specific data types, to that a program should have access.
  • These data types are included within the header associated with every function. One of the foremost common examples is the file system header <stdio.h>, that provides the type FILE that’s necessary for file operations.
  • The second reason to incorporate headers is to get the prototypes for the standard library functions. Function prototypes permit stronger type checking to be performed by the compiler.

Below is a list of header files used in C.



Character testing and conversion functions

Mathematical functions


I/O library functions

Utility functions


String handling functions

Time handling functions

Below is the list of Functions included in different Header Files with their purpose.



Determine if argument is alphanumeric


Determine if argument is alphabetic

Determine if argument is an ASCII character


Determine if argument is an ASCII control character


Determine if argument is a decimal digit


Determine if argument is a graphic printing ASCII character


Determine if argument is lowercase

Determine if argument is an octal digit


Determine if argument is a printing ASCII character

Determine if argument is a punctuation character




Return the arc cosine of d

Return the arc sine of d


Return the arc tangent of d

Return the arc tangent of d1/d2


Return a value rounded up to the next higher integer

Return the cosine of d


Return the hyperbolic cosine of d

Raise e to the power d


Return the absolute value of d

Return a value rounded down to the next lower integer




Closes file f

Determine if an end-of-line condition has been reached


Enter a single character form file f

Enter string s, containing i characters, from file f


Send data items to file f

Send a single character to file f


Send string s to file f

Enter i2 data items, each of size i1 bytes, from file f to string s


Enter data items from file f

Move the pointer to file f, a distance 1 byte from location i




Returns the absolute value of i

Converts string s to a double-precision quantity


Converts string s to an integer

Converts string s to a long integer


Allocates memory for an array having u1 elements, each of length u2 bytes

Closes all files and buffers, and terminates the program


Free a block of allocated memory whose beginning is indicated by p

Allocate u bytes of memory


Returns a random positive integer

Allocate u bytes of new memory to the pointer p



Compare two strings lexicographically


Compare two strings lexicographically, without regard to case

Copy string s2 to string s1


Return the number of characters in string s

Set all characters within s to c (except null character \0)




Return the time difference 11~12

Return the number of seconds elapsed beyond a designated base time