Read File While Being Written With Nimax

C File management

A File tin can be used to store a large book of persistent information. Like many other languages 'C' provides following file management functions,

1. Creation of a file
2. Opening a file
3. Reading a file
4. Writing to a file
5. Closing a file

Following are the almost important file management functions bachelor in 'C,'

part	purpose
fopen ()	Creating a file or opening an existing file
fclose ()	Closing a file
fprintf ()	Writing a cake of data to a file
fscanf ()	Reading a block data from a file
getc ()	Reads a single character from a file
putc ()	Writes a single grapheme to a file
getw ()	Reads an integer from a file
putw ()	Writing an integer to a file
fseek ()	Sets the position of a file pointer to a specified location
ftell ()	Returns the current position of a file pointer
rewind ()	Sets the file pointer at the commencement of a file

In this tutorial, y'all will learn-

• How to Create a File
• How to Shut a file:
• Writing to a File
• fputc() Part:
• fputs () Function:
• fprintf()Function:
• Reading information from a File
• Interactive File Read and Write with getc and putc

How to Create a File

Whenever you want to work with a file, the first step is to create a file. A file is nothing but space in a memory where data is stored.

To create a file in a 'C' program following syntax is used,

FILE *fp; fp = fopen ("file_name", "manner");          

In the in a higher place syntax, the file is a information construction which is defined in the standard library.

fopen is a standard role which is used to open up a file.

• If the file is not nowadays on the system, then it is created and then opened.
• If a file is already present on the arrangement, so information technology is direct opened using this part.

fp is a file pointer which points to the blazon file.

Whenever you lot open or create a file, you accept to specify what y'all are going to do with the file. A file in 'C' programming can be created or opened for reading/writing purposes. A mode is used to specify whether you want to open a file for any of the below-given purposes. Following are the dissimilar types of modes in 'C' programming which can be used while working with a file.

File Manner	Description
r	Open a file for reading. If a file is in reading mode, then no data is deleted if a file is already present on a system.
w	Open a file for writing. If a file is in writing fashion, then a new file is created if a file doesn't exist at all. If a file is already nowadays on a system, then all the data inside the file is truncated, and it is opened for writing purposes.
a	Open a file in append manner. If a file is in suspend way, then the file is opened. The content inside the file doesn't change.
r+	open for reading and writing from beginning
w+	open up for reading and writing, overwriting a file
a+	open for reading and writing, appending to file

In the given syntax, the filename and the mode are specified as strings hence they must always be enclosed within double quotes.

Instance:

#include <stdio.h> int main() { FILE *fp; fp  = fopen ("information.txt", "w"); }          

Output:

File is created in the same folder where yous take saved your code.

You lot can specify the path where you want to create your file

#include <stdio.h> int chief() { FILE *fp; fp  = fopen ("D://data.txt", "w"); }

How to Close a file

One should always close a file whenever the operations on file are over. It ways the contents and links to the file are terminated. This prevents adventitious damage to the file.

'C' provides the fclose function to perform file closing performance. The syntax of fclose is as follows,

fclose (file_pointer);          

Instance:

FILE *fp; fp  = fopen ("data.txt", "r"); fclose (fp);          

The fclose office takes a file pointer as an statement. The file associated with the file pointer is and then closed with the help of fclose function. It returns 0 if close was successful and EOF (stop of file) if there is an error has occurred while file closing.

After endmost the file, the same file arrow can also be used with other files.

In 'C' programming, files are automatically shut when the program is terminated. Closing a file manually by writing fclose function is a adept programming practise.

Writing to a File

In C, when you write to a file, newline characters '\n' must be explicitly added.

The stdio library offers the necessary functions to write to a file:

• fputc(char, file_pointer): It writes a character to the file pointed to by file_pointer.
• fputs(str, file_pointer): It writes a string to the file pointed to by file_pointer.
• fprintf(file_pointer, str, variable_lists): It prints a cord to the file pointed to by file_pointer. The string can optionally include format specifiers and a list of variables variable_lists.

The program beneath shows how to perform writing to a file:

fputc() Function:

#include <stdio.h> int principal() {         int i;         FILE * fptr;         char fn[l];         char str[] = "Guru99 Rocks\n";         fptr = fopen("fputc_test.txt", "w"); // "w" defines "writing mode"         for (i = 0; str[i] != '\n'; i++) {             /* write to file using fputc() office */             fputc(str[i], fptr);         }         fclose(fptr);         return 0;     }

Output:

The in a higher place program writes a unmarried graphic symbol into the fputc_test.txt file until it reaches the adjacent line symbol "\n" which indicates that the sentence was successfully written. The process is to have each graphic symbol of the assortment and write information technology into the file.

1. In the above program, nosotros have created and opened a file chosen fputc_test.txt in a write mode and declare our cord which will exist written into the file.
2. We practice a character by character write performance using for loop and put each character in our file until the "\n" graphic symbol is encountered then the file is closed using the fclose office.

fputs () Office:

#include <stdio.h> int main() {         FILE * fp;         fp = fopen("fputs_test.txt", "west+");         fputs("This is Guru99 Tutorial on fputs,", fp);         fputs("We don't need to employ for loop\north", fp);         fputs("Easier than fputc part\n", fp);         fclose(fp);         return (0);     }

OUTPUT:

1. In the above programme, nosotros have created and opened a file chosen fputs_test.txt in a write style.
2. After nosotros do a write operation using fputs() function past writing iii different strings
3. So the file is airtight using the fclose office.

fprintf()Function:

#include <stdio.h>     int main() {         FILE *fptr;         fptr = fopen("fprintf_test.txt", "w"); // "w" defines "writing mode"         /* write to file */         fprintf(fptr, "Learning C with Guru99\n");         fclose(fptr);         return 0;     }

OUTPUT:

1. In the higher up program we have created and opened a file called fprintf_test.txt in a write mode.
2. Subsequently a write performance is performed using fprintf() part by writing a cord, and then the file is closed using the fclose role.

Reading data from a File

At that place are 3 different functions defended to reading data from a file

• fgetc(file_pointer): It returns the next grapheme from the file pointed to by the file arrow. When the finish of the file has been reached, the EOF is sent back.
• fgets(buffer, n, file_pointer): Information technology reads n-1 characters from the file and stores the cord in a buffer in which the Zilch grapheme '\0' is appended as the last character.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): It is used to parse and analyze information. Information technology reads characters from the file and assigns the input to a list of variable pointers variable_adresses using conversion specifiers. Go on in mind that as with scanf, fscanf stops reading a string when space or newline is encountered.

The following program demonstrates reading from fputs_test.txt file using fgets(),fscanf() and fgetc () functions respectively :

#include <stdio.h> int main() {         FILE * file_pointer;         char buffer[30], c;          file_pointer = fopen("fprintf_test.txt", "r");         printf("----read a line----\due north");         fgets(buffer, 50, file_pointer);         printf("%south\n", buffer);          printf("----read and parse data----\northward");         file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer         char str1[10], str2[2], str3[20], str4[two];         fscanf(file_pointer, "%due south %s %s %s", str1, str2, str3, str4);         printf("Read String1 |%southward|\northward", str1);         printf("Read String2 |%s|\n", str2);         printf("Read String3 |%s|\n", str3);         printf("Read String4 |%s|\north", str4);          printf("----read the entire file----\n");          file_pointer = fopen("fprintf_test.txt", "r"); //reset the arrow         while ((c = getc(file_pointer)) != EOF) printf("%c", c);          fclose(file_pointer);         render 0;     }

Issue:

----read a line---- Learning C with Guru99  ----read and parse data---- Read String1 |Learning| Read String2 |C| Read String3 |with| Read String4 |Guru99| ----read the unabridged file---- Learning C with Guru99

1. In the above plan, we have opened the file called "fprintf_test.txt" which was previously written using fprintf() part, and it contains "Learning C with Guru99" string. We read information technology using the fgets() function which reads line by line where the buffer size must be enough to handle the entire line.
2. We reopen the file to reset the pointer file to point at the kickoff of the file. Create various strings variables to handle each word separately. Print the variables to see their contents. The fscanf() is mainly used to extract and parse data from a file.
3. Reopen the file to reset the pointer file to point at the starting time of the file. Read data and impress it from the file graphic symbol by character using getc() function until the EOF statement is encountered
4. After performing a reading operation file using unlike variants, we again closed the file using the fclose function.

Interactive File Read and Write with getc and putc

These are the simplest file operations. Getc stands for get character, and putc stands for put grapheme. These ii functions are used to handle only a single character at a time.

Following program demonstrates the file handling functions in 'C' programming:

#include <stdio.h> int main() {         FILE * fp;         char c;         printf("File Treatment\n");         //open a file         fp = fopen("demo.txt", "w");         //writing operation         while ((c = getchar()) != EOF) {             putc(c, fp);         }         //shut file         fclose(fp);         printf("Data Entered:\n");         //reading         fp = fopen("demo.txt", "r");         while ((c = getc(fp)) != EOF) {             printf("%c", c);         }         fclose(fp);         return 0;     }          

Output:

1. In the above program nosotros accept created and opened a file chosen demo in a write mode.
2. Later on a write operation is performed, then the file is closed using the fclose function.
3. We take again opened a file which at present contains data in a reading mode. A while loop will execute until the eof is constitute. In one case the end of file is found the performance will be terminated and data volition be displayed using printf office.
4. After performing a reading functioning file is again closed using the fclose function.

Summary

• A file is a space in a memory where data is stored.
• 'C' programming provides diverse functions to bargain with a file.
• A mechanism of manipulating with the files is called as file management.
• A file must exist opened earlier performing operations on it.
• A file tin can be opened in a read, write or an suspend mode.
• Getc and putc functions are used to read and write a single grapheme.
• The office fscanf() permits to read and parse data from a file
• We can read (using the getc function) an entire file by looping to cover all the file until the EOF is encountered
• We tin can write to a file after creating its proper name, by using the function fprintf() and it must take the newline graphic symbol at the cease of the string text.

Read File While Being Written With Nimax

Source: https://www.guru99.com/c-file-input-output.html

Share this post