BCA112_BCA117_Computer Programming

244 Computer Programming UNIT 10 DYNAMIC MEMORY ALLOCATION Structure: 10.0 Learning Objectives 10.1 Introduction 10.2 Dynamic Memory Allocation Functions 10.3 Summary 10.4 Key Words/Abbreviations 10.5 Learning Activity 10.6 Unit End Questions (MCQ and Descriptive) 10.7 References 10.0 Learning Objectives After studying this unit, you will be able to:  Describe the concepts of dynamic memory allocation  Demonstrate the use of malloc and calloc functions  Differentiate between malloc and calloc functions  Develop programs using DMA  Differentiate between static and dynamic memory allocation 10.1 Introduction Since C is a structured language, it has some fixed rules for programming. One of it includes changing the size of an array. An array is collection of items stored at continuous memory locations. CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 245 As it can be seen that the length (size) of the array above made is 9. But what if there is a requirement to change this length (size). For Example,  If there is a situation where only 5 elements are needed to be entered in this array. In this case, the remaining 4 indices are just wasting memory in this array. So there is a requirement to lessen the length (size) of the array from 9 to 5.  Take another situation. In this, there is an array of 9 elements with all 9 indices filled. But there is a need to enter 3 more elements in this array. In this case 3 indices more are required. So the length (size) of the array needs to be changed from 9 to 12. This procedure is referred to as Dynamic Memory Allocation in C. Therefore, C Dynamic Memory Allocation can be defined as a procedure in which the size of a data structure (like Array) is changed during the runtime. C provides some functions to achieve these tasks. There are 4 library functions provided by C defined under <stdlib.h> header  file  to  facilitate  dynamic memory  allocation  in  C  programming. They are: 1. malloc() 2. calloc() 3. free() 4. realloc() 10.1.1 Memory Allocation Process Global variables, static variables and program instructions get their memory in permanent storage area whereas local variables are stored in area called Stack. The memory space between CU IDOL SELF LEARNING MATERIAL (SLM)

246 Computer Programming these two region is known as Heap area. This region is used for dynamic memory allocation during execution of the program. The size of heap keep changing. Local Variable Stack Heap Free Memory Permanent Global Variable Storage Area Program Ins truction Static Variable Fig. 10.1: Memory Allocation Process 10.1.2 Allocating Memory Dynamically While programming, if you are aware of the size of an array, then it is easy and you can define it as an array. For example, to store a name of any person, it can go up to a maximum of 100 characters, so you can define something as follows “ char name[100]; Now let us consider a situation where you have no idea about the length of the text you need to store, for example, you want to store a detailed description about a topic. Here we need to define a pointer to character without defining how much memory is required and later, based on requirement, we can allocate memory as shown in the below example “ #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char name[100]; char *description; CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 247 strcpy(name, “Zara Ali”); /* allocate memory dynamically */ description = malloc( 200 * size of(char) ); if(description == NULL ) { fprintf(stderr, “Error - unable to allocate required memory\\n”); } else { Strcpy (description, “Zara ali a DPS student in class 10th”); } printf(“Name = %s\\n”, name ); printf(“Description: %s\\n”, description ); } When the above code is compiled and executed, it produces the following result. Name = Zara Ali Description: Zara ali a DPS student in class 10th Same program can be written using calloc(); only thing is you need to replace malloc with calloc as follows “ calloc(200, sizeof(char)); So you have complete control and you can pass any size value while allocating memory, unlike arrays where once the size defined, you cannot change it. 10.1.3 Resizing and Releasing Memory When your program comes out, operating system automatically release all the memory allocated by your program but as a good practice when you are not in need of memory anymore then you should release that memory by calling the function free(). Alternatively, you can increase or decrease the size of an allocated memory block by calling the function realloc(). Let us check the above program once again and make use of realloc() and CU IDOL SELF LEARNING MATERIAL (SLM)

248 Computer Programming free() functions – #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char name[100]; char *description; strcpy(name, “Shrutkirti Shelar”); /* allocate memory dynamically */ description = malloc( 30 * sizeof(char) ); if( description == NULL ) { fprintf(stderr, “Error - unable to allocate required memory\\n”); } else { strcpy( description, “Shrutkirti Shelar a CS student”); } /* suppose you want to store bigger description */ description = realloc( description, 100 * sizeof(char) ); if( description == NULL ) { fprintf(stderr, “Error - unable to allocate required memory\\n”); } else { strcat( description, “She is in Computer Science class”); } printf(“Name = %s\\n”, name ); printf(“Description: %s\\n”, description ); CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 249 /* release memory using free() function */ free(description); } When the above code is compiled and executed, it produces the following result. Name = Shrutkirti Shelar Description: Shrutkirti Shelar a CS student. She is in Computer Science class You can try the above example without re-allocating extra memory, and strcat() function will give an error due to lack of available memory in description. 10.2 Dynamic Memory Allocation Functions C dynamic memory allocation refers to performing manual memory management for dynamic memory allocation in the C programming language via a group of functions in the C standard library, namely malloc, realloc, calloc and free 10.2.1 malloc() By using malloc() we can create the memory dynamically at initial stage. malloc() required one argument of type size type that is data type size malloc() will creates the memory in bytes format. malloc() through created memory initial value is garbage.  malloc() function is used to allocate space in memory during the execution of the program.  malloc() does not initialize the memory allocated during execution. It carries garbage value.  malloc() function returns null pointer if it couldn’t able to allocate requested amount of memory. The name malloc stands for “memory allocation”. The function malloc() reserves a block of memory of specified size and return apointer of type void which can be casted into pointer of any form. Syntax of malloc() ptr = (cast-type*) malloc(byte-size) CU IDOL SELF LEARNING MATERIAL (SLM)

250 Computer Programming Here, ptr is pointer of cast-type. The malloc() function returns a pointer to an area of memory with size of byte size. If the space is insufficient, allocation fails and returns NULL pointer. ptr = (int*) malloc(100 * sizeof(int)); This statement will allocate either 200 or 400 according to size of int 2 or 4 bytes respectively and the pointer points to the address of first byte of memory. Example of malloc(): #include <stdio.h> #include <string.h> #include <stdlib.h> int main() { char *mem_allocation; /* memory is allocated dynamically */ mem_allocation = malloc( 20 * sizeof(char) ); if( mem_allocation== NULL ) { printf(“Couldn’t able to allocate requested memory\\n”); } else { strcpy( mem_allocation, “God is great”); } printf(“Dynamically allocated memory content : “ \\ “%s\\n”, mem_allocation ); free(mem_allocation); } CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 251 Output: Dynamically allocated memory content: God is great 10.2.2 calloc(), calloc() function is also like malloc() function. But calloc() initializes the allocated memory to zero. But, malloc() doesn’t.  By using calloc() we can create the memory dynamically at initial stage.  calloc() required 2 arguments of type count, size-type.  Count will provide number of elements; size-type is data type size.  calloc() will creates the memory in blocks format.  Initial value of the memory is zero. C calloc() The name calloc stands for “contiguous allocation” The only difference between malloc() and calloc() is that, malloc() allocates single block of memory whereas calloc() allocates multiple blocks of memory each of same size and sets all bytes to zero. Syntax of calloc() ptr = (cast-type*)calloc(n, element-size); This statement will allocate contiguous space in memory for an array of nelements. For example: ptr = (float*) calloc(25, sizeof(float)); This statement allocates contiguous space in memory for an array of 25 elements each of size of float, i.e., 4 bytes. Example of calloc(): #include <stdio.h> #include <string.h> #include <stdlib.h> CU IDOL SELF LEARNING MATERIAL (SLM)

252 Computer Programming int main() { char *mem_allocation; /* memory is allocated dynamically */ mem_allocation = calloc( 20, sizeof(char) ); if( mem_allocation== NULL ) { printf(“Couldn’t able to allocate requested memory\\n”); } else { strcpy( mem_allocation, “God is great”); } printf(“Dynamically allocated memory content : “ \\ “%s\\n”, mem_allocation ); free(mem_allocation); } Output: Dynamically allocated memory content: God is great 10.2.3 realloc()  realloc() function modifies the allocated memory size by malloc() and calloc() functions to new size.  If enough space doesn’t exist in memory of current block to extend, new block is allocated for the full size of reallocation, then copies the existing data to new block and then frees the old block.  By using realloc() we can create the memory dynamically at middle stage.  Generally by using realloc() we can reallocation the memory. CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 253  realloc() required 2 arguments of type void*, size_type.  Void* will indicates previous block base address, size-type is data type size.  realloc() will creates the memory in bytes format and initial value is garbage. C realloc() If the previously allocated memory is insufficient or more than required, you can change the previously allocated memory size using realloc(). Syntax of realloc() ptr = realloc(ptr, newsize); Here, ptr is reallocated with size of newsize. Example: Using realloc() #include <stdio.h> #include <stdlib.h> int main() { int *ptr, i , n1, n2; printf(“Enter size of array: “); scanf(“%d”, &n1); ptr = (int*) malloc(n1 * sizeof(int)); printf(“Address of previously allocated memory: “); for(i = 0; i < n1; ++i) printf(“%u\\t”,ptr + i); printf(“\\nEnter new size of array: “); scanf(“%d”, &n2); ptr = realloc(ptr, n2); for(i = 0; i < n2; ++i) CU IDOL SELF LEARNING MATERIAL (SLM)

254 Computer Programming printf(“%u\\t”, ptr + i); return 0; } 10.2.4 free() free() function frees the allocated memory by malloc(), calloc(), realloc() functions and returns the memory to the system. C free() Dynamically allocated memory created with either calloc() or malloc() doesn’t get freed on its own. You must explicitly use free() to release the space. syntax of free() free(ptr); This statement frees the space allocated in the memory pointed by ptr. #include <stdio.h> #include <string.h> #include <stdlib.h> void main() { char *mem_allocation; /* memory is allocated dynamically */ mem_allocation = malloc( 20 * sizeof(char) ); if( mem_allocation == NULL ) { printf(“Couldn’t able to allocate requested memory\\n”); } else { CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 255 strcpy( mem_allocation,” God is great “); } printf(“Dynamically allocated memory content : “ \\”%s\\n”, mem_allocation ); mem_allocation=realloc(mem_allocation,100*sizeof(char)); if( mem_allocation == NULL ) { printf(“Couldn’t able to allocate requested memory\\n”); } else { strcpy( mem_allocation,”space is extended up to “ \\”100 characters”); } printf(“Resized memory : %s\\n”, mem_allocation ); free(mem_allocation); getch( ); } Output: Dynamically allocated memory content : God is great Resized memory : space is extended up to 100 characters 10.2.5 Difference between Static Memory Allocation and Dynamic Memory Allocation in C Static Memory Allocation Dynamic Memory Allocation In dynamic memory allocation, memory is allocated In static memory allocation, memory is allocated while executing the program. That means at run time. while writing the C program. Actually, user requested memory will be allocated at compile Memory size can be modified while execution. time. Example: Linked list Memory size can’t be modified while execution. Example: Array CU IDOL SELF LEARNING MATERIAL (SLM)

256 Computer Programming 10.2.6 Difference between malloc() and calloc() Functions malloc() calloc() It allocates only single block of requested memory It allocates multiple blocks of requested memory Syntax :(cast_type *)calloc(blocks , Syntax :(cast_type *)malloc(Size_in_bytes); size_of_block); int *ptr;ptr = malloc( 20 * sizeof(int) );For the int *ptr;Ptr = calloc(20, 20 * sizeof(int)); For the above, 20*4 bytes of memory only allocated in above, 20 blocks of memory will be created and one block. Total = 80 bytes each contains 20*4 bytes of memory. Total = 1600 bytes malloc() doesn’t initializes the allocated memory. calloc () initializes the allocated memory to zero It contains garbage values type cast must be done since this function Same as malloc() function int *ptr;ptr = (int*) returns void pointer int *ptr;ptr = calloc( 20, 20 * sizeof(int) ); (int*)malloc(sizeof(int)*20); calloc() initializes the allocated memory with 0 malloc() initializes the allocated memory with value. garbage values. Number of arguments is 2 Number of argument is 1 10.3 Summary Dynamic memory allocation is an aspect of allocating and freeing memory according to your needs. Dynamic memory is managed and served with pointers that point to the newly allocated space of memory in an area which we call the heap. Now you can create and destroy an array of elements at runtime without any problems. To sum up, the automatic memory management uses the stack, and the dynamic memory allocation uses the heap. The <stdlib.h> library has functions responsible for dynamic memory management. 10.4 Key Words/Abbreviations  Dynamic: Characterized by constant change, activity, or progress.  calloc ()=: Allocates the space for elements of an array. Initializes the elements to zero and returns a pointer to the memory. CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 257  malloc (): Allocates the memory of requested size and returns the pointer to the first byte of allocated space.  realloc(): It is used to modify the size of previously allocated memory space.  free(): Frees or empties the previously allocated memory space. 10.5 Learning Activity 1. What is the use of free() method? ......................................................................................................................................... ......................................................................................................................................... 2. Explain Resizing and Releasing Memory ......................................................................................................................................... ......................................................................................................................................... 10.6 Unit End Questions (MCQ and Descriptive) A. Descriptive Type: Short Answer Type Questions 1. What is dynamic memory allocation? Explain with process. 2. Explain the dynamic memory allocation functions. 3. What is dynamic memory allocation? Explain allocating and releasing memory. 4. What is the use of malloc() and calloc() function? 5. Write a short note on free() and size of operator. B. Multiple Choice/Objective Type Questions 1. Which of the following is/are true (a) calloc() allocates the memory and also initializes the allocates memory to zero, while memory allocated using malloc() has random data. (b) malloc() and memset() can be used to get the same effect as calloc(). (c) calloc() takes two arguments, but malloc takes only 1 argument. (d) All of the above CU IDOL SELF LEARNING MATERIAL (SLM)

258 Computer Programming 2. What is the return type of malloc() or calloc() (a) void * (b) Pointer of allocated memory type (c) void ** (d) int * 3. Which of the following is true? (a) “ptr = calloc(m, n)” is equivalent to following ptr = malloc(m * n); (b) “ptr = calloc(m, n)” is equivalent to following ptr = malloc(m * n); memset(ptr, 0, m * n); (c) “ptr = calloc(m, n)” is equivalent to following ptr = malloc(m); memset(ptr, 0, m); (d) “ptr = calloc(m, n)” is equivalent to following ptr = malloc(n); memset(ptr, 0, n); 4. Which languages necessarily need heap allocation in the run time environment? (a) Those that support recursion (b) Those that use dynamic scoping (c) Those that use global variables (d) Those that allow dynamic data structures 5. We use malloc and calloc for (a) Dynamic memory allocation (b) Static memory allocation (c) Both dynamic and static memory allocation (d) None of the above Answers: 1. (d), 2. (a), 3. (b), 4. (d), 5. (a) CU IDOL SELF LEARNING MATERIAL (SLM)

Dynamic Memory Allocation 259 10.7 References 1. https://www.geeksforgeeks.org/dynamic-memory-allocation-in-c-using-malloc-calloc- free-and-realloc/ 2. https://www.guru99.com/c-dynamic-memory-allocation.html 3. https://www.unf.edu/~wkloster/2220/ppts/malloc.pdf 4. https://www.cs.cmu.edu/~guna/15-123S11/Lectures/Lecture08.pdf  CU IDOL SELF LEARNING MATERIAL (SLM)

260 Computer Programming UNIT 11 C PREPROCESSOR Structure: 11.0 Learning Objectives 11.1 Introduction 11.2 Concepts of Preprocessor 11.3 Preprocessor Directives 11.4 Predefined Macros 11.5 Parameterized Macros. 11.6 Summary 11.7 Key Words/Abbreviations 11.8 Learning Activity 11.9 Unit End Questions (MCQ and Descriptive) 11.10 References 11.0 Learning Objectives After studying this unit, you will be able to:  Explain the concepts of preprocessor  Describe preprocessor directives  Elaborate the concepts of predefined macros  Discuss the concepts of parameterized macros CU IDOL SELF LEARNING MATERIAL (SLM)

C Preprocessor 261 11.1 Introduction In C compilation  model  and  processes,  the C source  code  is  passed  to  a preprocessor before being transferred to the compiler. The preprocessor interprets all preprocessor directives or macros by substituting the macros by their contents. The preprocessor has its own syntax which is different from the C syntax. All the preprocessor begins with a hash ( #) sign e.g., #define, #include 11.2 Concepts of Preprocessor A Preprocessor is a system software (a computer program that is designed to run on computer’s hardware and application programs). It performs preprocessing of the High Level Language (HLL). Preprocessing is the first step of the language processing system. Language processing system translates the high level language to machine level language or absolute machine code (i.e., to the form that can be understood by machine).  The preprocessor doesn’t know about the scope rules of C. Preprocessor directives like #define come into effect as soon as they are seen and remain in effect until the end of the file that contains them; the program’s block structure is irrelevant. Fig. 11.1: Preprocessing Steps of the High Level Language (HLL) CU IDOL SELF LEARNING MATERIAL (SLM)

262 Computer Programming File inclusion: Including all the files from library that our program needs. In HLL we write #include which is a directive for the preprocessor that tells  it to include the contents of the library file specified. For example, #include will tell the preprocessor to include all the contents in the library file stdio.h. This can also be written using double quotes – #include “stdio.h” Macro expansion: Macros can be called as small functions that are not as overhead to process. If we have to write a function (having a small definition) that needs to be called recursively (again and again), then we should prefer a macro over a function. So, defining these macros is done by preprocessor. #define SI 1000 11.3 Preprocessor Directives Preprocessor Table 11.1: List of Preprocessor Directives Macro Header file inclusion Syntax/Description    Conditional compilation Syntax: #defineThis macro defines constant value and can be any of Other directives the basic data types. Syntax: #include <file_name>The source code of the file “file_name” is included in the main program at the specified place. Syntax: #ifdef, #endif, #if, #else, #ifndefSet of commands are included or excluded in source program before compilation with respect to the condition.  Syntax: #undef, #pragma#undef is used to undefine a defined macro variable. #Pragma is used to call a function before and after main function in a C program. It is Constant defining section, this section is prefixed by # sign # define pi 3.1415 # is preprocessor directive which gives direction to the compiler that define pi as a constant value for the program. It is also called as Macro defined. CU IDOL SELF LEARNING MATERIAL (SLM)

C Preprocessor 263 Macro: #define This macro defines constant value and can be any of the basic data types. These constants are usually defined at the beginning of a program. They may then appear later in the program in place of the numeric constants, character constants, etc. that the macro may represent. The syntax to use define macro is as follows: #define name value Where name represents a symbolic name, typically written in uppercase letters, and text represents the sequence of characters that is associated with the symbolic name. Note that text does not end with a semicolon, since a symbolic constant definition is not a true C statement. Let’s see an example: #define PI 3.14 void main() { float radius=1.2; float area_of_circle = PI * radius * radius; float circumference_of_circle = 2 * PI * radius; printf(“\\n Details of circle”); printf(“\\n Area = %f”, area_of_circle); printf(“\\n Circumference = %f”, circumference_of_circle); } In the above program, instead of writing the value of 3.14 for calculating area and circumference of circle, a constant PI which is defined before the main() method is used. #define PI 3.14 This statement is called ‘macro definition’ or more commonly, just a ‘macro’. The preprocessor replaces every occurrence of PI in the program with 3.14.  File Inclusion: #include The second preprocessor directive causes one file to be included in another. The preprocessor command for file inclusion looks like this: #include <file_name>   CU IDOL SELF LEARNING MATERIAL (SLM)

264 Computer Programming The source code of the file “file_name” is included in the main( ) function C program where “#include <file_name>” is mentioned. Of course this assuming that the file being included is existing. This directive is normally used for very large programs which can be divided into several different files each containing related functions. These files are #include at the beginning of main( ) function program file. Secondly, the commonly needed functions and macro definitions can be stored in a file, and that file can be included in every program later. The prototypes of all the library functions are grouped into different categories and then stored in different header files. For example prototypes of all mathematics related functions are stored in the header file ‘math.h’ which can be included as shown below: #include<math.h> The #include directive can be used in two ways as discussed below: #include “filename” #include <filename> #include “sum.c” #include “c:\\employee.c” It is Link section also called as include section, this section is prefixed by # sign # include<stdio.h> # include<conio.h> # include<math.h> # include<stdlib.h> # is preprocessor directive which gives direction to the compiler that include specified header file from Library to main( ) function program. Table 11.2: List of Header Files Header File Description #include<stdio.h> It is standard input output header files, consist of standard input function #include<conio.h> scanf() and standard output function printf() #include<math.h> It is console input output header file, consist of clrscr() function to clear screen and getch() function to get character to see the output on screen. It is Math medical Header File Consist of all mathematical functions, sin( ), cos( ), tan( ), sqrt( ). CU IDOL SELF LEARNING MATERIAL (SLM)

C Preprocessor 265 #include<stdlib.h It is standard Library File consist of Exit( ) function #include<string.h> It is string header File consist of string functions, strcmp( ), strlen( ), #include<Ctype.h> strcpy( ), strrev( ), strcat( ). All character handling functions are defined in this header file.functionsIt consist of islower( ), isupper( ), isdigit( ) Preprocessor is also called Macro Definition. # define max 100 Hence # is a preprocessor directive which directs to the compiler that identifier max as a token replaced with the string 100. Hence in the program each occurance of max is automatically replaced by 100. Examples: # define true 1 # define false 0 # define EoF – 1 # define product (x, y) ((x) * (y)) 11.4 Predefined Macros Predefined Macros A predefined macro is a macro that is already understood by the C preprocessor without the program needing to define it. Here are some predefined macros in C programming. Table 11.3: Predefined Macros in C Macro Value __DATE__ A string containing the current date __FILE__ A string containing the file name __LINE__ An integer representing the current line number __STDC__ If follows ANSI standard C, then the value is a nonzero integer __TIME__ A string containing the current date. CU IDOL SELF LEARNING MATERIAL (SLM)

266 Computer Programming Let’s try the following example - To Get current time using __TIME__ The following program outputs the current time using __TIME__ macro. 1. #include <stdio.h> 2. int main() 3. { 4. printf(“Current time: %s”,__TIME__); 5. } Output Current time: 19:54:39 Example: #include <stdio.h> int 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 CU IDOL SELF LEARNING MATERIAL (SLM)

C Preprocessor 267 11.5 Parameterized Macros Parameterized macros can be used to create templates for frequently used parts of code. Frequently, they serve as simple functions. #define helps to define a macro and the #undefine helps to remove a macro definition. Syntax of a parameterized macro is as follows: #define identifier(parameterlist) replacement-list There should be no spaces between the identifier and the parameter list. There should be no spaces in the parameter list. Example: #define getchar() getc(stdin) #define IS_EVEN(m) ((m)%2 == 0) #define max(a,b) (((a)>(b))?(a):(b)) #define toupper(x) ((‘a’<=(x)&&(x) z=”” x=”” -=”” a=”” :=”” br=””> #define print(y) printf(“%d\\n”,y) print(c/d) /* becomes printf(“%d\\n”,c/d); */ Advantages of a parameterized macro: The compiled code will execute more quickly because the macro is substituted in line. No function calling overhead is wanted. The parameters of functions are typed but in macros they are not typed. So, they are generic. The max() macro given example will perform for floats and also for ints. Disadvantages of a parameterized macro: The compiled code will often be larger, mostly when macros are nested (e.g., max(a,max(b,max(c,d))) ) because each instance of the macro is expanded in line. A macro may calculate its arguments more than once, producing subtle faults and it is not achievable to have a pointer to a macro. CU IDOL SELF LEARNING MATERIAL (SLM)

268 Computer Programming 11.6 Summary The C preprocessor is a macro processor that is used automatically by the C compiler to transform your program before actual compilation. It is called a macro processor because it allows you to define macros, which are brief abbreviations for longer constructs. The C preprocessor provides four separate facilities that you can use as you see fit:  Inclusion of header files. These are files of declarations that can be substituted into your program.  Macro expansion. You can define macros, which are abbreviations for arbitrary fragments of C code, and then the C preprocessor will replace the macros with their definitions throughout the program.  Conditional compilation. Using special preprocessing directives, you can include or exclude parts of the program according to various conditions.  Line control. If you use a program to combine or rearrange source files into an intermediate file which is then compiled, you can use line control to inform the compiler of where each source line originally came from. 11.7 Key Words/Abbreviations  Macro: A macro is a fragment of code which has been given a name. Whenever the name is used, it is replaced by the contents of the macro. There are two kinds of macros. They differ mostly in what they look like when they are used. Object-like macros resemble data objects when used, function-like macros resemble function calls.  preprocessor: The C Preprocessor is not a part of the compiler, but is a separate step in the compilation process. 11.8 Learning Activity 1. Explain #define. ....................................................................................................................................... ....................................................................................................................................... CU IDOL SELF LEARNING MATERIAL (SLM)

C Preprocessor 269 2. Explain predefined Macros. ....................................................................................................................................... ....................................................................................................................................... 11.9 Unit End Questions (MCQ and Descriptive) A. Descriptive Type: Short Answer Type Questions 1. Explain what is preprocessor in c language. 2. Describe different preprocessor directives in c language 3. Discuss what are predefined Macros in c language. 4. Elaborate Parameterized Macros in c language. B. Multiple Choice/Objective Type Questions 1. Which file is generated after preprocessing of a C program? (a) . p (b) .i (c) o (d) .m 2. C preprocessor (a) Takes care of conditional compilation (b) Takes care of macros (c) Takes care of include files (d) All of the aboce 3. A preprocessor command (a) need not start on a new line (b) need not start on the first column (c) has # as the first character (d) comes before the first executable statement CU IDOL SELF LEARNING MATERIAL (SLM)

270 Computer Programming 4. What is the Output of following code? #include<stdio.h>  #define f(g,g2) g##g2 int main() {      int var12 = 100;     printf(\"%d\", f(var,12));     return 0; } (a) 100 (b)  Compiler Error (c) 0 (d)  1 5.  What is the Output of following code? #include <stdio.h> #define square(x) x*x int main() {    int x;    x = 36/square(6);    printf(\"%d\", x);    return 0; } (a) 1 (b) 36 (c) 0 (d) Compiler Error Answers: 1. (b), 2. (d), 3. (c), 4. (a), 5. (b) CU IDOL SELF LEARNING MATERIAL (SLM)

C Preprocessor 271 11.10 References 1. https://gcc.gnu.org/onlinedocs/gcc-2.95.3/cpp_1.html 2. https://www.zentut.com/c-tutorial/c-preprocessor/ 3. The C Programming Language Ritchie & kernighan 4. http://www2.cs.uregina.ca/~hilder/cs833/Other%20Reference%20Materials/ The%20C%20Programming%20Language.pdf  CU IDOL SELF LEARNING MATERIAL (SLM)

272 Computer Programming UNIT 12 FILE MANAGEMENT Structure: 12.0 Learning Objectives 12.1 Introduction 12.2 File Types 12.3 File Handling Functions 12.4 Summary 12.5 Key Words/Abbreviations 12.6 Learning Activity 12.7 Unit End Questions (MCQ and Descriptive) 12.8 References 12.0 Learning Objectives After studying this unit, you will be able to:  Describe the concepts of file management  Know the File Modes  Discuss types of Files  Discuss different types of file handling functions 12.1 Introduction File Handling concept in C language is used for store a data permanently in computer memory. Using this concept we can store our data in Secondary memory (Hard disk). Afilerepresents a CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 273 sequence of bytes on the disk where a group of related data is stored. File is created for permanent storage of data. It is a readymade structure. All files related function are available instdio.hheader file. In C language, we use a structurepointer of file typeto declare a file. File Handling in C: 1. New way of dealing with data is file handling. 2. Data is stored onto the disk and can be retrieve whenever require. 3. Output of the program may be stored onto the disk. 4. In C we have many functions that deals with file handling. 5. A file is a collection of bytes stored on a secondary storage device(generally a disk) 6. Collection of byte may be interpreted as — – Single character – Single Word – Single Line – Complete Structure. File Operations There are 5 major operations can be performed on files 1. Creation of new file 2. Opening an existing file 3. Reading data from file 4. Writing data into file 5. Appending data into file 6. Closing a file. 12.1.1 File Operations There are 5 major operations can be performed on files 1. Creation of new file 2. Opening an existing file CU IDOL SELF LEARNING MATERIAL (SLM)

274 Computer Programming 3. Reading data from file 4. Writing data into file 5. Appending data into file 6. Closing a file. Table 12.1: Different File Operations File Operation/Syntax Description fopen function is used to open a file. file open Where, fp is file pointer to the data type “FILE”. FILE *fp; fp=fopen (“filename”, “mode”); fclose function closes the file that is being pointed by file pointer fp. file close: fgets is used to read a file line by line. where, buffer – fclose(fp); buffer to put the data in.size – size of the buffer fp – file pointer fprintf writes the data into a file pointed by fp. file read: fgets (buffer, size, fp); file write: fprintf (fp, “some data”); fprintf (fp, “text %d”, variable_name); Steps for processing C Files: 1. Declare a file pointer variable 2. Open a file using fopen( ) function by specifying mode of opening of a file. 3. If mode is read mode, then file should be already created with the contents 4. If mode is write mode, then it will create new file and data can be written on to the file. 5. If mode is append, the file should be already created with some contents and then we can add the contents at the end of the file. 6. Close a file by using fclose( ) function. Details of Explanation of Steps for Processing C Files: 1. Declare a file pointer variable When working with files, you need to declare a pointer of type file. This declaration is needed for communication between the file and program. FILE *fptr; CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 275 2. Open a file using fopen( ) function by specifying mode of opening of a file. Opening a file is performed using the library function in the “stdio.h” header file: fopen() function. The syntax for opening a file in standard I/O is: fptr = fopen(“fileopen”,”mode”) For Example: fopen(“E:\\\\cprogram\\\\kirantxtfile.txt”,”w”); //For Text Mode fopen(“E:\\\\cprogram\\\\kiranbinfile.bin”,”rb”); // For Binary Mode 3. If mode is read mode, then file should be already created with the contents Reading a Text File Reading from text file can be done by getc( ) and gets( ) function This is the simplest function to read a single character from a file H 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 H. This is the simplest function to read a string from a file H 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> void main() { FILE *fp; CU IDOL SELF LEARNING MATERIAL (SLM)

276 Computer Programming char buff[255]; fp = fopen(“/tmp/kiran.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() read 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.  Reading Binary File fread( ) function is used to read from binary file. size_t fread(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. 4. If mode is write mode, then it will create new file and data can be written on to the file. CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 277 Writing a File fputc( ) and fputs( ) functions are used to write characters and strings into text files. 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> void main() { FILE *fp; fp = fopen(“/tmp/kiranbinary.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 kiranbinary.txt in /tmp directory and writes two lines using two different functions. Let us read this file in the next section. Example: Write to a text file using fprintf() #include <stdio.h> void main() CU IDOL SELF LEARNING MATERIAL (SLM)

278 Computer Programming { int num; FILE *fptr; fptr = fopen(“C:\\\\kiran.txt”, “w”); if(fptr == NULL) { printf(“Error!”); exit(1); } printf(“Enter num:”); scanf(“%d”,&num); fprintf(fptr,”%d”,num); fclose(fptr); getch( ); } This program takes a number from user and stores in the file kiran.txt. After you compile and run this program, you can see a text file program.txt created in C drive of your computer. When you open the file, you can see the integer you entered. fwrite( ) function is used to write into binary file. size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file); 5. If mode is append, the file should be already created with some contents and then we can add the contents at the end of the file. The syntax for opening a file in append mode is:- fopen(“E:\\\\cprogram\\\\kirantxtfile.txt”,”a”); //For Text Mode fopen(“E:\\\\cprogram\\\\kiranbinfile.bin”, “ab+”); // For Binary Mode #include <stdio.h> CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 279 void main() { FILE *fp file = fopen(“kiran.txt”,”a”); fprintf(fp, “%s”,”This is just an example of text appended by kiran :)”); /*append some text*/ fclose(fp); getch( ); } 6. Close a file by using fclose( ) function. The fclose( ) function is used to close an already opened file. General Syntax : int fclose( FILE *fp ); Here fclose() function closes the file and returns zero on success, or EOF (End of File) if there is an error in closing the file. This EOF is a constant defined in the header file stdio.h. FILE *fp; fclose(fp); 12.1.2 Mode of Operations Performed on a File: (Modes) There are many modes in opening a file. Based on the mode of file, it can be opened for reading or writing or appending the texts. They are listed below. Table 12.2: Different File Modes Types Opening Mode Purpose Previous Data Reading Writing File will be opened just for reading purpose Retained Appending File will be opened just for writing purpose Flushed File will be opened for appending some thing in file Retained CU IDOL SELF LEARNING MATERIAL (SLM)

280 Computer Programming  r – Opens a file in read mode and sets pointer to the first character in the file. It returns null if file does not exist.  w – Opens a file in write mode. It returns null if file could not be opened. If file exists, data are overwritten.  a – Opens a file in append mode. It returns null if file couldn’t be opened.  r+ – Opens a file for read and write mode and sets pointer to the first character in the file. w+ – Opens a file for read and write mode and sets pointer to the first character in the file.  a+ – Opens a file for read and write mode and sets pointer to the first character in the file. But, it can’t modify existing contents. Table 12.3: Different File Modes File Mode Meaning of Mode During Inexistence of File r Open for reading. If the file does not exist, fopen() returns NULL. rb Open for reading in binary mode. If the file does not exist, fopen() returns NULL. w Open for writing. If the file exists, its contents are overwritten. If the file does not exist, it will be created. Wb Open for writing in binary mode. If the file exists, its contents are overwritten. If the file does not exist, it will be created. a Open for append, i.e., Data is added to end of file. If the file does not exists, it will be created. ab Open for append in binary mode, i.e., Data is If the file does not exists, it will be added to end of file. created. r+ Open for both reading and writing. If the file does not exist, fopen() returns NULL. rb+ Open for both reading and writing in binary mode. If the file does not exist, fopen() returns NULL. w+ Open for both reading and writing. If the file exists, its contents are overwritten. If the file does not exist, it will be created. CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 281 wb+ Open for both reading and writing in binary mode. If the file exists, its contents are overwritten. If the file does not exist, it will be created. a+ Open for both reading and appending. If the file does not exists, it will be created. ab+ Open for both reading and appending in If the file does not exists, it will be binary mode. created. 12.2 File Types What is File? File is a collection of bytes that is stored on secondary storage devices like disk. There are two kinds of files in a system. They are, 1. Text files (ASCII) Text files contain ASCII codes of digits, alphabetic and symbols 2. Binary files Binary file contains collection of bytes (0s and 1s). Binary files are compiled version of text files. A file is a collection of bytes stored on a secondary storage device, which is generally a disk of some kind. The collection of bytes may be interpreted, for example, as characters, words, lines, paragraphs and pages from a textual document; fields and records belonging to a database; or pixels from a graphical image. The meaning attached to a particular file is determined entirely by the data structures and operations used by a program to process the file. It is conceivable (and it sometimes happens) that a graphics file will be read and displayed by a program designed to process textual data. Essentially there are two kinds of files that programmers deal with text files and binary files. ASCII Text files Text files are the normal .txt files that you can easily create using Notepad or any simple text editors. CU IDOL SELF LEARNING MATERIAL (SLM)

282 Computer Programming A text file can be a stream of characters that a computer can process sequentially. It is not only processed sequentially but only in forward direction. For this reason a text file is usually opened for only one kind of operation (reading, writing, or appending) at any given time. Similarly, since text files only process characters, they can only read or write data one character at a time. (In C Programming Language, Functions are provided that deal with lines of text, but these still essentially process data one character at a time.) When you open those files, you will see all the contents within the file as plain text. You can easily edit or delete the contents. They take minimum effort to maintain are easily readable and provide least security and takes bigger storage space. Binary Files Binary file are mostly the .bin files in your computer. Instead of storing data in plain text, they store it in the binary form (0s and 1s). They can hold higher amount of data are not readable easily and provides a better security than text files. Binary files can be either processed sequentially or, depending on the needs of the application, they can be processed using random access techniques. In C Programming Language, processing a file using random access techniques involves moving the current file position to an appropriate place in the file before reading or writing data. This indicates a second characteristic of binary files. They a generally processed using read and write operations simultaneously. 12.3 File Handling Functions 12.3.1 fopen() The fopen() function is used to open a file and associates an I/O stream with it. This function takes two arguments. The first argument is a pointer to a string containing name of the file to be opened while the second argument is the mode in which the file is to be opened. FILE *fopen(const char *path, const char *mode); The mode can be: ‘r’: Open text file for reading. The stream is positioned at the beginning of the file. ‘r+’: Open for reading and writing. The stream is positioned at the beginning of the file. CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 283 ‘w’: Truncate file to zero length or create text file for writing. The stream is positioned at the beginning of the file. ‘w+’: Open for reading and writing. The file is created if it does not exist, otherwise it is truncated. The stream is positioned at the beginning of the file. ‘a’: Open for appending (writing at end of file). The file is created if it does not exist. The stream is positioned at the end of the file. ‘a+’: Open for reading and appending (writing at end of file). The file is created if it does not exist. The initial file position for reading is at the beginning of the file, but output is always appended to the end of the file. The fopen() function returns a FILE stream pointer on success while it returns NULL in case of a failure. 12.3.2 fclose() The fclose() function first flushes the stream opened by fopen() and then closes the underlying descriptor. Upon successful completion this function returns 0 else end of file (eof) is returned. In case of failure, if the stream is accessed further then the behaviour remains undefined. int fclose(FILE *fp); For example, Program to open and close a file: #include<stdio.h> #include<stdlib.h> int main() { FILE *fptr; If((fptr = fopen(“TEST”,”w”))==NULL) { printf(“Cannot open file\\n”); exit(1); } CU IDOL SELF LEARNING MATERIAL (SLM)

284 Computer Programming if(fclose(fptr)) pritf(“File close error\\n”); return o; } 12.3.3 fgetc() 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 ); Example : #include<stdio.h> void main() { FILE *fp; char ch; fp = fopen(“file.txt”, “w”); //Statement 1 if(fp == NULL) { printf(“\\nCan’t open file or file doesn’t exist.”); exit(0); } while((ch=getchar())!=EOF) //Statement 2 fputc(ch,fp); printf(“\\nData written successfully...”); fclose(fp); } CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 285 Output: Hello friends, my name is Shruti Data written successfully... 12.3.4 fputc() 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. Make sure you have /tmp directory available. If it is not, then before proceeding, you must create this directory on your machine. Following is the simplest function to write individual characters to a stream “ int fputc( int c, FILE *fp ); Example: #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. CU IDOL SELF LEARNING MATERIAL (SLM)

286 Computer Programming 12.3.5 fgets() The functions fgets() reads up to n-1 characters from the input stream referenced by fp. It copies the read string into the bufferbuf, 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); } Output: 1. This 2. is testing for fprintf... 3. This is testing for fputs... CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 287 12.3.6 fputs() The fputs() function is used to write string (array of characters) to the file. fputs(char str[], FILE *fp); The fputs() function takes two arguments, first is the string to be written to the file and second is the file pointer where the string will be written. #include<stdio.h> void main() { FILE *fp; char str[]; fp = fopen(“kiran.txt”, “w”); //Statement 1 if(fp == NULL) { printf(“\\nCan’t open file or file doesn’t exist.”); exit(0); } do { gets(str); fputs(str,fp); }while(strlen(str)!=0); printf(“\\nData written successfully...”); fclose(fp); } Output: C is a general-purpose programming language. It is developed by Dennis Ritchie. CU IDOL SELF LEARNING MATERIAL (SLM)

288 Computer Programming Data written successfully.. In the above example, statement 1 will create a file named kiran.txt in write mode. Statement 2 is a loop, which take strings from user and write the strings to the file, until user input an empty string. 12.3.7 fscanf() The fscanf() function is used to read mixed type form the file. Syntax of fscanf() function fscanf(FILE *fp, “format-string”,var-list); The fscanf() function is similar to scanf() function except the first argument which is a file pointer that specifies the file to be read. Example of fscanf() function #include<stdio.h> void main() { FILE *fp; char ch; fp = fopen(“kiran.txt”, “r”); //Statement 1 if(fp == NULL) { printf(“\\nCan’t open file or file doesn’t exist.”); exit(0); } printf(“\\nData in file...\\n”); while((fscanf(fp, “%d%s%f”,&roll,name,&marks))!=EOF) //Statement 2 printf(“\\n%d\\t%s\\t%f”,roll,name,marks); fclose(fp); } CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 289 Output: Data in file... 1 Shruti 81.65 2 Kiran 82.62 In the above example, Statement 1 will open an existing file file.txt in read mode and statement 2 will read all the data up to EOF(end-of-file) reached. 12.3.8 fprintf() So far we have seen writing of characters, strings and integers in different files. This is not enough if we need to write characters, strings and integers in one single file, for that purpose we use fprintf() function. The fprintf() function is used to write mixed type in the file. Syntax of fprintf() function fprintf(FILE *fp, “format-string”,var-list); The fprintf() function is similar to printf() function except the first argument which is a file pointer that specifies the file to be written. Example of fprintf() function #include<stdio.h> void main() { FILE *fp; int roll; char name[25]; float marks; char ch; fp = fopen(“file.txt”, “w”); //Statement 1 if(fp == NULL) { printf(“\\nCan’t open file or file doesn’t exist.”); CU IDOL SELF LEARNING MATERIAL (SLM)

290 Computer Programming exit(0); } do { printf(“\\nEnter Roll :”); scanf(“%d”,&roll); printf(“\\nEnter Name :”); scanf(“%s”,name); printf(“\\nEnter Marks :”); scanf(“%f”,&marks); fprintf(fp, “%d%s%f”,roll,name,marks); printf(“\\nDo you want to add another data (y/n) :”); ch = getche(); }while(ch==‘y’ || ch==‘Y’); printf(“\\nData written successfully...”); fclose(fp); } Output: Enter Roll : 11 Enter Name : Shruti Enter Marks : 78.53 Do you want to add another data (y/n) : y Enter Roll : 21 Enter Name : Kirti Enter Marks : 89.62 Do you want to add another data (y/n) : n Data written successfully... CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 291 12.3.9 getw() The getw() function is used to read integer value form the file. Syntax of getw() function int getw(FILE *fp); The getw() function takes the file pointer as argument from where the integer value will be read and returns returns the end-of-file if it has reached the end of file. Example of getw() function #include<stdio.h> void main() { FILE *fp; int num; fp = fopen(“file.txt”, “r”); //Statement 1 if(fp == NULL) { printf(“\\nCan’t open file or file doesn’t exist.”); exit(0); } printf(“\\nData in file...\\n”); while((num = getw(fp))!=EOF) //Statement 2 printf(“\\n%d”,num); fclose(fp); } CU IDOL SELF LEARNING MATERIAL (SLM)

292 Computer Programming Output: Data in file... 78 45 63 In the above example, Statement 1 will open an existing file file.txt in read mode and statement 2 will read all the integer values up to EOF(end-of-file) reached. 12.3.10 putw() The putw() function is used to write integers to the file. Syntax of putw() function putw(int number, FILE *fp); The putw() function takes two arguments, first is an integer value to be written to the file and second is the file pointer where the number will be written. #include<stdio.h> void main() { FILE *fp; int num; char ch=‘n’; fp = fopen(“file.txt”, “w”); //Statement 1 if(fp == NULL) { printf(“\\nCan’t open file or file doesn’t exist.”); exit(0); } do //Statement 2 CU IDOL SELF LEARNING MATERIAL (SLM)

File Management 293 { printf(“\\nEnter any number :”); scanf(“%d”,&num); putw(num,fp); printf(“\\nDo you want to another number :”); ch = getche(); }while(ch==‘y’||ch==‘Y’); printf(“\\nData written successfully...”); fclose(fp); } Output: Enter any number : 78 Do you want to another number : y Enter any number : 45 Do you want to another number : y Enter any number : 63 Do you want to another number : n Data written successfully... In the above example, statement 1 will create a file named file.txt in write mode. Statement 2 is a loop, which take integer values from user and write the values to the file. 12.3.11 fread() and fwrite() The functions fread/fwrite are used for reading/writing data from/to the file opened by fopen function. These functions accept three arguments. The first argument is a pointer to buffer used for reading/writing the data. The data read/written is in the form of ‘nmemb’ elements each ‘size’ bytes long. CU IDOL SELF LEARNING MATERIAL (SLM)