HEADER FILES

HEADER FILES

A header file is a file with extension .h which contains C function declarations
and macro definitions to be shared between several source files. There are two
types of header files: the files that the programmer writes and the files that
comes with your compiler.

You request to use a header file in your program by including it with the C
preprocessing directive #include, like you have seen inclusion of stdio.h header
file, which comes along with your compiler.

Including a header file is equal to copying the content of the header file but we
do not do it because it will be error-prone and it is not a good idea to copy the
content of a header file in the source files, especially if we have multiple source
files in a program.
A simple practice in C or C++ programs is that we keep all the constants,
macros, system wide global variables, and function prototypes in the header files
and include that header file wherever it is required.

Include Syntax

Both the user and the system header files are included using the preprocessing
directive #include. It has the following two forms:

#include <file>

This form is used for system header files. It searches for a file named ‘file’ in a
standard list of system directories. You can prepend directories to this list with
the -I option while compiling your source code.

#include "file"

This form is used for header files of your own program. It searches for a file
named ‘file’ in the directory containing the current file. You can prepend
directories to this list with the -I option while compiling your source code.

Include Operation

The #include directive works by directing the C preprocessor to scan the
specified file as input before continuing with the rest of the current source file.
The output from the preprocessor contains the output already generated,
followed by the output resulting from the included file, followed by the output
that comes from the text after the #include directive. For example, if you have
a header file header.h as follows:
24. HEADER FILES

char *test (void);

and a main program called program.c that uses the header file, like this:

int x; #include "header.h" int main (void) { puts (test ()); } the compiler will see the same token stream as it would if program.c read. int x; char *test (void); int main (void) { puts (test ()); }

Once-Only Headers

If a header file happens to be included twice, the compiler will process its
contents twice and it will result in an error. The standard way to prevent this is
to enclose the entire real contents of the file in a conditional, like this:

#ifndef HEADER_FILE #define HEADER_FILE the entire header file file #endif

This construct is commonly known as a wrapper #ifndef. When the header is
included again, the conditional will be false, because HEADER_FILE is defined.
The preprocessor will skip over the entire contents of the file, and the compiler
will not see it twice.

Computed Includes

Sometimes it is necessary to select one of the several different header files to be
included into your program. For instance, they might specify configuration
parameters to be used on different sorts of operating systems. You could do this
with a series of conditionals as follows:

#if SYSTEM_1 # include "system_1.h" #elif SYSTEM_2 # include "system_2.h" #elif SYSTEM_3 ... #endif

But as it grows, it becomes tedious, instead the preprocessor offers the ability to
use a macro for the header name. This is called a computed include. Instead
of writing a header name as the direct argument of #include, you simply put a
macro name there:

#define SYSTEM_H "system_1.h" ... #include SYSTEM_H

SYSTEM_H will be expanded, and the preprocessor will look for system_1.h as if
the #include had been written that way originally. SYSTEM_H could be defined
by your Makefile with a -D option.

PREPROCESSORS

PREPROCESSORS

The C Preprocessor is not a part of the compiler, but is a separate step in the
compilation process. In simple terms, a C Preprocessor is just a text substitution
tool and it instructs the compiler to do required preprocessing before the actual
compilation. We'll refer to the C Preprocessor as CPP.
All preprocessor commands begin with a hash symbol (#). It must be the first
nonblank character, and for readability, a preprocessor directive should begin in
the first column. The following section lists down all the important preprocessor
directives:

Directive                                                                             Description
#define Substitutes a preprocessor macro.
#include Inserts a particular header from another file.
#undef Undefines a preprocessor macro.
#ifdef Returns true if this macro is defined.
#ifndef Returns true if this macro is not defined.
#if Tests if a compile time condition is true.
#else The alternative for #if.
#elif #else and #if in one statement.
#endif Ends preprocessor conditional.
#error Prints error message on stderr.
#pragma Issues special commands to the compiler, using a standardized PREPROCESSORS
method.

Preprocessors Examples

Analyze the following examples to understand various directives.

#define MAX_ARRAY_LENGTH 20

This directive tells the CPP to replace instances of MAX_ARRAY_LENGTH with 20.
Use #define for constants to increase readability.

#include <stdio.h> #include "myheader.h"

These directives tell the CPP to get stdio.h from System Libraries and add the
text to the current source file. The next line tells CPP to get myheader.h from
the local directory and add the content to the current source file.

#undef FILE_SIZE #define FILE_SIZE 42

It tells the CPP to undefine existing FILE_SIZE and define it as 42.

#ifndef MESSAGE #define MESSAGE "You wish!" #endif

It tells the CPP to define MESSAGE only if MESSAGE isn't already defined.

#ifdef DEBUG /* Your debugging statements here */ #endif

It tells the CPP to process the statements enclosed if DEBUG is defined. This is
useful if you pass the -DDEBUG flag to the gcc compiler at the time of
compilation. This will define DEBUG, so you can turn debugging on and off onthe-fly during compilation.

Predefined Macros

ANSI C defines a number of macros. Although each one is available for use in
programming, the predefined macros should not be directly modified.

Macro                                                                       Description
__DATE__ The current date as a character literal in "MMM DD YYYY"
format.
__TIME__ The current time as a character literal in "HH:MM:SS" format.
__FILE__ This contains the current filename as a string literal.
__LINE__ This contains the current line number as a decimal constant.
__STDC__ Defined as 1 when the compiler complies with the ANSI
standard.
Let's try the following example:

#include <stdio.h> main() { printf("File :%s\n", __FILE__ ); printf("Date :%s\n", __DATE__ ); printf("Time :%s\n", __TIME__ ); printf("Line :%d\n", __LINE__ ); printf("ANSI :%d\n", __STDC__ ); }

When the above code in a file test.c is compiled and executed, it produces the
following result:

File :test.c Date :Jun 2 2012 Time :03:36:24 Line :8 ANSI :1

Preprocessor Operators

The C preprocessor offers the following operators to help create macros:
TheMacro Continuation (\)Operator
A macro is normally confined to a single line. The macro continuation operator
(\) is used to continue a macro that is too long for a single line. For example:

#define message_for(a, b) \ printf(#a " and " #b ": We love you!\n")

TheStringize(#)Operator
The stringize or number-sign operator (#), when used within a macro definition,
converts a macro parameter into a string constant. This operator may be used
only in a macro having a specified argument or parameter list. For example:

#include <stdio.h> #define message_for(a, b) \ printf(#a " and " #b ": We love you!\n") int main(void) { message_for(Carole, Debra); return 0; }

When the above code is compiled and executed, it produces the following result:

Carole and Debra: We love you!

TheToken Pasting(##)Operator

The token-pasting operator (##) within a macro definition combines two
arguments. It permits two separate tokens in the macro definition to be joined
into a single token. For example:

#include <stdio.h> #define tokenpaster(n) printf ("token" #n " = %d", token##n) int main(void) { int token34 = 40; tokenpaster(34); return 0; }

When the above code is compiled and executed, it produces the following result:

token34 = 40

It happened so because this example results in the following actual output from
the preprocessor:

printf ("token34 = %d", token34);

This example shows the concatenation of token##n into token34 and here we
have used both stringize and token-pasting.

TheDefined() Operator

The preprocessor defined operator is used in constant expressions to determine
if an identifier is defined using #define. If the specified identifier is defined, the
value is true (non-zero). If the symbol is not defined, the value is false (zero).
The defined operator is specified as follows:

#include <stdio.h> #if !defined (MESSAGE) #define MESSAGE "You wish!" #endif int main(void) { printf("Here is the message: %s\n", MESSAGE); return 0; }

When the above code is compiled and executed, it produces the following result:

Here is the message: You wish!

Parameterized Macros

One of the powerful functions of the CPP is the ability to simulate functions using
parameterized macros. For example, we might have some code to square a
number as follows:

int square(int x) { return x * x; }

We can rewrite the above code using a macro as follows:

#define square(x) ((x) * (x))

Macros with arguments must be defined using the #define directive before they
can be used. The argument list is enclosed in parentheses and must immediately
follow the macro name. Spaces are not allowed between the macro name and
open parenthesis. For example:

#include <stdio.h> #define MAX(x,y) ((x) > (y) ? (x) : (y)) int main(void) { printf("Max between 20 and 10 is %d\n", MAX(10, 20)); return 0; }

When the above code is compiled and executed, it produces the following result:

Max between 20 and 10 is 20

FILE I/O

FILE I/O

The last chapter explained the standard input and output devices handled by C
programming language. This chapter covers how C programmers can create,
open, close text or binary files for their data storage.
A file represents a sequence of bytes, regardless of it being a text file or a binary
file. C programming language provides access on high-level functions as well as
low-level (OS level) calls to handle file on your storage devices. This chapter will
take you through the important calls for file management.

Opening Files

You can use the fopen( ) function to create a new file or to open an existing file.
This call will initialize an object of the type FILE, which contains all the
information necessary to control the stream. The prototype of this function call is
as follows:
FILE *fopen( const char * filename, const char * mode );
Here, filename is a string literal, which you will use to name your file, and
access mode can have one of the following values:

Mode Description

r Opens an existing text file for reading purpose.
w Opens a text file for writing. If it does not exist, then a new file is
created. Here your program will start writing content from the
beginning of the file.
a Opens a text file for writing in appending mode. If it does not exist,
then a new file is created. Here your program will start appending
content in the existing file content.
r+ Opens a text file for both reading and writing.
w+ Opens a text file for both reading and writing. It first truncates the file
to zero length if it exists, otherwise creates a file if it does not exist.
22. FILE I/O
a+ Opens a text file for both reading and writing. It creates the file if it
does not exist. The reading will start from the beginning but writing
can only be appended.
If you are going to handle binary files, then you will use the following access
modes instead of the above-mentioned ones:

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

Closing a File

To close a file, use the fclose( ) function. The prototype of this function is:

int fclose( FILE *fp );

The fclose() function returns zero on success, or EOF if there is an error in
closing the file. This function actually flushes any data still pending in the buffer
to the file, closes the file, and releases any memory used for the file. The EOF is
a constant defined in the header file stdio.h.
There are various functions provided by C standard library to read and write a
file, character by character, or in the form of a fixed length string.

Writing a File

Following is the simplest function to write individual characters to a stream:

int fputc( int c, FILE *fp );

The function fputc() writes the character value of the argument c to the output
stream referenced by fp. It returns the written character written on success
otherwise EOF if there is an error. You can use the following functions to write a
null-terminated string to a stream:

int fputs( const char *s, FILE *fp );

The function fputs() writes the string s to the output stream referenced by fp. It
returns a non-negative value on success, otherwise EOF is returned in case of
any error. You can use int fprintf(FILE *fp,const char *format, ...) function
as well to write a string into a file. Try the following example.

Make sure you have /tmp directory available. If it is not, then before
proceeding, you must create this directory on your machine.

#include <stdio.h> main() { FILE *fp; fp = fopen("/tmp/test.txt", "w+"); fprintf(fp, "This is testing for fprintf...\n"); fputs("This is testing for fputs...\n", fp); fclose(fp); }

When the above code is compiled and executed, it creates a new file test.txt in
/tmp directory and writes two lines using two different functions. Let us read this
file in the next section.

Reading a File

Given below is the simplest function to read a single character from a file:

int fgetc( FILE * fp );

The fgetc() function reads a character from the input file referenced by fp. The
return value is the character read, or in case of any error, it returns EOF. The
following function allows to read a string from a stream:

char *fgets( char *buf, int n, FILE *fp );

The functions fgets() reads up to n - 1 characters from the input stream
referenced by fp. It copies the read string into the buffer buf, appending
a null character to terminate the string.

If this function encounters a newline character '\n' or the end of the file EOF
before they have read the maximum number of characters, then it returns only
the characters read up to that point including the new line character. You can
also use int fscanf(FILE *fp, const char *format, ...) function to read strings
from a file, but it stops reading after encountering the first space character.

#include <stdio.h> main() { FILE *fp; char buff[255]; fp = fopen("/tmp/test.txt", "r"); fscanf(fp, "%s", buff); printf("1 : %s\n", buff ); fgets(buff, 255, (FILE*)fp); printf("2: %s\n", buff ); fgets(buff, 255, (FILE*)fp); printf("3: %s\n", buff ); fclose(fp); }

When the above code is compiled and executed, it reads the file created in the
previous section and produces the following result:

1 : This 2: is testing for fprintf... 3: This is testing for fputs...

Let's see a little more in detail about what happened here. First, fscanf() reads
just This because after that, it encountered a space, second call is
for fgets() which reads the remaining line till it encountered end of line. Finally,
the last call fgets() reads the second line completely.
Binary I/O Functions
There are two functions that can be used for binary input and output:

size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file); size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

Both of these functions should be used to read or write blocks of memories -
usually arrays or structures.

INPUT AND OUTPUT

INPUT AND OUTPUT

When we say Input, it means to feed some data into a program. An input can be
given in the form of a file or from the command line. C programming provides a
set of built-in functions to read the given input and feed it to the program as per
requirement.

When we say Output, it means to display some data on screen, printer, or in
any file. C programming provides a set of built-in functions to output the data on
the computer screen as well as to save it in text or binary files.

The Standard Files

C programming treats all the devices as files. So devices such as the display are
addressed in the same way as files and the following three files are
automatically opened when a program executes to provide access to the
keyboard and screen.

Standard File                                File Pointer                                    Device Standard input                                 stdin                                                   Keyboard Standard output                               stdout                                                 Screen Standard error                                  stderr                                                 Your screen

The file pointers are the means to access the file for reading and writing
purpose. This section explains how to read values from the screen and how to
print the result on the screen.

The getchar() and putchar() Functions

The int getchar(void) function reads the next available character from the
screen and returns it as an integer. This function reads only single character at a
time. You can use this method in the loop in case you want to read more than
one character from the screen.

The int putchar(int c) function puts the passed character on the screen and
returns the same character. This function puts only single character at a time.
You can use this method in the loop in case you want to display more than one
character on the screen. Check the following example:

#include <stdio.h> int main( ) { int c; printf( "Enter a value :"); c = getchar( ); printf( "\nYou entered: "); putchar( c ); return 0; }

When the above code is compiled and executed, it waits for you to input some
text. When you enter a text and press enter, then the program proceeds and
reads only a single character and displays it as follows:

$./a.out Enter a value : this is test You entered: t

The gets() and puts()Functions

The char *gets(char *s) function reads a line from stdin into the buffer
pointed to by s until either a terminating newline or EOF (End of File).
The int puts(const char *s) function writes the string ‘s’ and ‘a’ trailing
newline to stdout.

When the above code is compiled and executed, it waits for you to input some
text. When you enter a text and press enter, then the program proceeds and
reads the complete line till end, and displays it as follows:

$./a.out Enter a value : this is test You entered: This is test

The scanf() and printf()Functions

The int scanf(const char *format, ...) function reads the input from the
standard input stream stdin and scans that input according to the
format provided.
The int printf(const char *format, ...) function writes the output to the
standard output stream stdout and produces the output according to the format
provided.
The format can be a simple constant string, but you can specify %s, %d, %c,
%f, etc., to print or read strings, integer, character, or float, respectively. There
are many other formatting options available which can be used based on
requirements. Let us now proceed with a simple example to understand the
concepts better:

#include <stdio.h> int main( ) { char str[100]; int i; printf( "Enter a value :"); scanf("%s %d", str, &i); printf( "\nYou entered: %s %d ", str, i); return 0; }

When the above code is compiled and executed, it waits for you to input some
text. When you enter a text and press enter, then program proceeds and reads
the input and displays it as follows:

$./a.out Enter a value : seven 7 You entered: seven 7

Here, it should be noted that scanf() expects input in the same format as you
provided %s and %d, which means you have to provide valid inputs like "string
integer". If you provide "string string" or "integer integer", then it will be
assumed as wrong input. Secondly, while reading a string, scanf() stops reading
as soon as it encounters a space, so "this is test" are three strings for scanf().

TYPEDEF

TYPEDEF

The C programming language provides a keyword called typedef, which you can
use to give a type, a new name. Following is an example to define a
term BYTE for one-byte numbers:

typedef unsigned char BYTE;

After this type definition, the identifier BYTE can be used as an abbreviation for
the type unsigned char, for example:

BYTE b1, b2;

By convention, uppercase letters are used for these definitions to remind the
user that the type name is really a symbolic abbreviation, but you can use
lowercase, as follows:

typedef unsigned char byte;

You can use typedef to give a name to your user-defined data types as well. For
example, you can use typedef with structure to define a new data type and then
use that data type to define structure variables directly as follows:

#include <stdio.h> #include <string.h> typedef struct Books { char title[50]; char author[50]; char subject[100]; int book_id; } Book; int main( ) { Book book; strcpy( book.title, "C Programming"); strcpy( book.author, "Nuha Ali"); strcpy( book.subject, "C Programming Tutorial"); book.book_id = 6495407; printf( "Book title : %s\n", book.title); printf( "Book author : %s\n", book.author); printf( "Book subject : %s\n", book.subject); printf( "Book book_id : %d\n", book.book_id); return 0; }

When the above code is compiled and executed, it produces the following result:

Book title : C Programming Book author : Nuha Ali Book subject : C Programming Tutorial Book book_id : 6495407

typedef  vs #define

#define is a C-directive which is also used to define the aliases for various data
types similar to typedef but with the following differences:

· typedef is limited to giving symbolic names to types only,
whereas #define can be used to define alias for values as well, e.g., you
can define 1 as ONE, etc.

· typedef interpretation is performed by the compiler whereas #define
statements are processed by the preprocessor.

The following example shows how to use #define in a program:

#include <stdio.h> #define TRUE 1 #define FALSE 0 int main( ) { printf( "Value of TRUE : %d\n", TRUE); printf( "Value of FALSE : %d\n", FALSE); return 0; }

When the above code is compiled and executed, it produces the following result:

Value of TRUE : 1 Value of FALSE : 0

BIT FIELDS

BIT FIELDS

Suppose your C program contains a number of TRUE/FALSE variables grouped in
a structure called status, as follows:

struct { unsigned int widthValidated; unsigned int heightValidated; } status;

This structure requires 8 bytes of memory space but in actual, we are going to
store either 0 or 1 in each of the variables. The C programming language offers
a better way to utilize the memory space in such situations.

If you are using such variables inside a structure, then you can define the width
of a variable which tells the C compiler that you are going to use only those
number of bytes. For example, the above structure can be rewritten as follows:

struct { unsigned int widthValidated : 1; unsigned int heightValidated : 1; } status;

The above structure requires 4 bytes of memory space for status variable, but
only 2 bits will be used to store the values.

If you will use up to 32 variables, each one with a width of 1 bit, then also the
status structure will use 4 bytes. However, as soon as you have 33 variables, it
will allocate the next slot of the memory and it will start using 8 bytes. Let us
check the following example to understand the concept:

#include <stdio.h> #include <string.h> /* define simple structure */ struct { unsigned int widthValidated; unsigned int heightValidated; } status1; /* define a structure with bit fields */ struct { unsigned int widthValidated : 1; unsigned int heightValidated : 1; } status2; int main( ) { printf( "Memory size occupied by status1 : %d\n", sizeof(status1)); printf( "Memory size occupied by status2 : %d\n", sizeof(status2)); return 0; }

When the above code is compiled and executed, it produces the following result:

Memory size occupied by status1 : 8 Memory size occupied by status2 : 4

Bit Field Declaration

The declaration of a bit-field has the following form inside a structure:

struct { type [member_name] : width ; };

The following table describes the variable elements of a bit field:

Elements        Description
type An integer type that determines how a bit-field's value is
interpreted. The type may be int, signed int, or unsigned int.
member_name The name of the bit-field.
width The number of bits in the bit-field. The width must be less
than or equal to the bit width of the specified type.
The variables defined with a predefined width are called bit fields. A bit field can
hold more than a single bit; for example, if you need a variable to store a value
from 0 to 7, then you can define a bit-field with a width of 3 bits as follows:

struct { unsigned int age : 3; } Age;

The above structure definition instructs the C compiler that the age variable is
going to use only 3 bits to store the value. If you try to use more than 3 bits,
then it will not allow you to do so. Let us try the following example:

#include <stdio.h> #include <string.h> struct { unsigned int age : 3; } Age; int main( ) { Age.age = 4; printf( "Sizeof( Age ) : %d\n", sizeof(Age) ); printf( "Age.age : %d\n", Age.age ); Age.age = 7; printf( "Age.age : %d\n", Age.age ); Age.age = 8; printf( "Age.age : %d\n", Age.age ); return 0; }

When the above code is compiled, it will compile with a warning and when
executed, it produces the following result:

Sizeof( Age ) : 4 Age.age : 4 Age.age : 7 Age.age : 0

UNIONS

UNIONS

A union is a special data type available in C that allows to store different data
types in the same memory location. You can define a union with many
members, but only one member can contain a value at any given time. Unions
provide an efficient way of using the same memory location for multiple
purpose.

Defining a Union

To define a union, you must use the union statement in the same way as you
did while defining a structure. The union statement defines a new data type with
more than one member for your program. The format of the union statement is
as follows:

union [union tag] { member definition; member definition; ... member definition; } [one or more union variables];

The union tag is optional and each member definition is a normal variable
definition, such as int i; or float f; or any other valid variable definition. At the
end of the union's definition, before the final semicolon, you can specify one or
more union variables, but it is optional. Here is the way you would define a
union type named Data having three members i, f, and str:

union Data { int i; float f; char str[20]; } data;

Now, a variable of Data type can store an integer, a floating-point number, or a
string of characters. It means a single variable, i.e., same memory location, can
18. UNIONS
be used to store multiple types of data. You can use any built-in or user-defined
data types inside a union based on your requirement.
The memory occupied by a union will be large enough to hold the largest
member of the union. For example, in the above example, Data type will occupy
20 bytes of memory space because this is the maximum space which can be
occupied by a character string. The following example displays the total memory
size occupied by the above union:

#include <stdio.h> #include <string.h> union Data { int i; float f; char str[20]; }; int main( ) { union Data data; printf( "Memory size occupied by data : %d\n", sizeof(data)); return 0; }

When the above code is compiled and executed, it produces the following result:

Memory size occupied by data : 20

Accessing Union Members

To access any member of a union, we use the member access operator (.).
The member access operator is coded as a period between the union variable
name and the union member that we wish to access. You would use the keyword
union to define variables of union type. The following example shows how to
use unions in a program:

#include <stdio.h> #include <string.h> union Data { int i; float f; char str[20]; }; int main( ) { union Data data; data.i = 10; data.f = 220.5; strcpy( data.str, "C Programming"); printf( "data.i : %d\n", data.i); printf( "data.f : %f\n", data.f); printf( "data.str : %s\n", data.str); return 0; }

When the above code is compiled and executed, it produces the following result:

data.i : 1917853763 data.f : 4122360580327794860452759994368.000000 data.str : C Programming

Here, we can see that the values of i and f members of union got corrupted
because the final value assigned to the variable has occupied the memory
location and this is the reason that the value of str member is getting printed
very well.

Now let's look into the same example once again where we will use one variable
at a time which is the main purpose of having unions:

#include <stdio.h> #include <string.h> union Data { int i; float f; char str[20]; }; int main( ) { union Data data; data.i = 10; printf( "data.i : %d\n", data.i); data.f = 220.5; printf( "data.f : %f\n", data.f); strcpy( data.str, "C Programming"); printf( "data.str : %s\n", data.str); return 0; }

When the above code is compiled and executed, it produces the following result:

data.i : 10 data.f : 220.500000 data.str : C Programming

Here, all the members are getting printed very well because one member is
being used at a time.