C Programming header files and their functions

C header files and their functions is another important topic in C online tutorials. Here, you will know about header files in C language. Moreover, C header files and their uses is simple. However, you must practise header files in C example exercises. This way you will know C header files list as well. In addition, you will know include syntax, operation etc in header files.

What are header files in C language?

Header file in C programming is file with ‘.h’ extension. Moreover, this file has C function declarations. Even you can share macro definitions with other source files.

Furthermore, there are two different header files. One is files which programmer writes. While other are files which you get from computer.

Steps to use header file in C program

You may even use header file in C program. For this you must include C pre-processing directive ‘#include’. This is similar to C compiler’s header.

Steps to include syntax in C program

As we told you pre-processor includes system and user header files. Moreover, it uses directive ‘#include’. But it has two forms.

Form 1:to include syntax

#include <file>

You will use this form for system header files. This looks for ‘file’ in standard list of system directories. Furthermore, you may add directories before to list. For this you should use –I option. You must remember to do this when you compile source code.

Form 2: to include syntax

#include “file”

You use this form for header files. It looks for ‘file’ in directory. This directory has current file. Moreover, you can attach directories before list. But for this you must use –I option. This happens when compiling source code.

Steps to include operation in a C program

You must use ‘#include’ directive. Because this directs C pre-processor. In addition, you may scan specific file as input. To know more continue reading. We gave example program for your understanding. You may also read C operators to know better.

Example program

Once only headers in C language

Compiler processes contents twice. This case happens when you include header file twice. As a resultthere will be an error. However, you may prevent this. For this you must enclose real contents of file. Remember to do it in condition.

Example program

Note:

Whenever header is inclusive.Conditional turns to be false.Because here, you defined HEADER_FILE.Hence, pre-processor skips contents of file. Thus, compiler does not see it twice.

Computed includes

Conditions are helpful in programs. In addition, it will be advantage. Because this will select only one of different header files.You will include these files in program. You can check example program to understand it.

Program example

Computed include means that pre-processor uses macro for header name. Therefore, with ‘#include’ you may write header name. Finally this will be macro name.

Henceyou now know header files in C with their uses. But do not forget to practise C header files with functions examples. This chapter will help you with Type casting in C.

C programming input and output functions

C file I/O is second part of C input and output functions in C language. In this chapter you will understand C programming file i/o examples. In addition, you can find file i/o in C using system calls. However, to know more C language file I/O, you can continue reading.  Finally, you will know about C binary file I/O as well.

What is file I/O in C tutorials?

In this chapter, you will go in detail about C programming file I/O functions. Plus, you will know process for creating or opening or closing text. Even binary files follow these steps. As this will help them with data storage.

What is file in C language?

File indicates sequence of bytes in C language. Moreover, these can be either binary or text file. It is also easy to handle files in storage devices. It is so because programming language has options to access functions. These functions can be high level or low level (OS level) calls.

Opening files in C programming language

Here you will learn opening multiple files in C language. In addition opening binary files in C is easy. fopen() function is useful to create new file. Moreover, you can open existing file as well. This function initializes object of type FILE. And this will have information on controlling stream.

Prototype of fopen() function is –

FILE *fopen( const char * filename, const char * mode );

In prototype, filename is string literal. This will name files. While access mode may have any one of the following values –

Closing files in C programming

You may even close files. But for this you must use fclose( ) function. And below you can find prototype of function

int fclose(  FILE  *fp  );

If successful, then fclose(-) function returns zero. However, it can be EOF also. This happens when there is error in closing files in C language. In addition, this function will remove data that is in buffer to file.

It will then close file and even release memory used for file. This EOF is constant. In addition, definition of it is in header file stdio.h. C standard library gives functions. These help you to read and write character by character. This list includes file or fixed length string.

Writing files in C programming language

Function to write characters to stream is –

int fputc( int c, FILE *fp );

fputc() function will write character value of argument c. This is for output stream which fp refers. Moreover, it will return written character on success. However, if there is error then it will be EOF.

You can write null terminated string to stream in following manner –

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

Besides, you must remember that fputs() function will write string s to output stream. Moreover, fp refers it. But it will return non negative value on success. While for errors, EOF returns.

To write C strings in file, you will use following function –

int fprintf(FILE *fp,const char *format, …)

Example program

Reading a file in C programming language online tutorial

Function for reading single character from file –

int fgetc( FILE * fp );

Function fgetc() reads character from input file. In addition, fp refers it. Return value is character read. However, for errors, EOF returns.

Function to read string from stream

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

Another aspect is that fgets() function will read till n-1 characters. Moreover., this is from input stream. Finally fp refers it. It will copy read string in buffer. Therefore, we add null character. As this will terminate string in C.

Read following example to understand it in a better way. However, remember one more point. You may use following function to read string –

int fscanf(FILE *fp, const char *format, …)

Example program

Binary I/O functions in C programming language

In C programming language, you will use binary input and output functions. In addition, you will use these functions to either write or read block of memories. Apart from this, memories here are structures(in C) and arrays(in C).In addition, you may check C functions.

Binary I/O functions in C language

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);

C - 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.

#include <stdio.h>
int main( ) {

   char str[100];

   printf( "Enter a value :");
   gets( str );

   printf( "\nYou entered: ");
   puts( str );

   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 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().

C - 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 where as #define can be used to define alias for values as well, q., you can define 1 as ONE etc.
• typedef interpretation is performed by the compiler whereas #define statements are processed by the pre-processor.

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

C - 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 re-written 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 −

Sr.No.	Element & Description
1	type An integer type that determines how a bit-field's value is interpreted. The type may be int, signed int, or unsigned int.
2	member_name The name of the bit-field.
3	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