How Ro Read the Data in a File and Put a Pointer From the Beginning

C File management

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

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

Post-obit are the most of import file management functions available in 'C,'

function	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 information from a file
getc ()	Reads a single graphic symbol from a file
putc ()	Writes a single graphic symbol to a file
getw ()	Reads an integer from a file
putw ()	Writing an integer to a file
fseek ()	Sets the position of a file arrow to a specified location
ftell ()	Returns the current position of a file pointer
rewind ()	Sets the file pointer at the beginning of a file

In this tutorial, you will learn-

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

How to Create a File

Whenever you desire to work with a file, the commencement step is to create a file. A file is zippo just space in a memory where information is stored.

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

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

In the above syntax, the file is a information structure which is divers in the standard library.

fopen is a standard function which is used to open a file.

• If the file is not nowadays on the system, and so it is created so opened.
• If a file is already nowadays on the system, then it is directly opened using this function.

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

Whenever yous open or create a file, you have 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 way is used to specify whether you want to open up a file for any of the below-given purposes. Post-obit are the different types of modes in 'C' programming which can exist used while working with a file.

File Mode	Description
r	Open a file for reading. If a file is in reading mode, and so no information is deleted if a file is already present on a system.
west	Open up a file for writing. If a file is in writing mode, and then a new file is created if a file doesn't exist at all. If a file is already present 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 mode. If a file is in suspend manner, and so the file is opened. The content within the file doesn't change.
r+	open up for reading and writing from offset
westward+	open 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 every bit strings hence they must always exist enclosed within double quotes.

Example:

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

Output:

File is created in the same folder where you accept saved your code.

You lot can specify the path where y'all want to create your file

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

How to Close a file

I should ever close a file whenever the operations on file are over. It means the contents and links to the file are terminated. This prevents accidental harm to the file.

'C' provides the fclose office to perform file closing operation. The syntax of fclose is equally follows,

fclose (file_pointer);          

Example:

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

The fclose office takes a file pointer equally an argument. The file associated with the file pointer is and so closed with the assistance of fclose function. It returns 0 if shut was successful and EOF (end of file) if at that place is an fault has occurred while file closing.

Afterwards closing the file, the same file pointer tin also be used with other files.

In 'C' programming, files are automatically close when the programme is terminated. Closing a file manually by writing fclose function is a good 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): Information technology writes a string to the file pointed to by file_pointer.
• fprintf(file_pointer, str, variable_lists): It prints a string to the file pointed to by file_pointer. The string can optionally include format specifiers and a list of variables variable_lists.

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

fputc() Function:

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

Output:

The in a higher place programme writes a single character into the fputc_test.txt file until it reaches the side by side line symbol "\northward" which indicates that the sentence was successfully written. The process is to take each character of the array and write it into the file.

1. In the to a higher place program, we have created and opened a file chosen fputc_test.txt in a write mode and declare our string which will be written into the file.
2. We practise a character past grapheme write operation using for loop and put each character in our file until the "\n" character is encountered and then the file is closed using the fclose function.

fputs () Function:

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

OUTPUT:

1. In the in a higher place program, we have created and opened a file called fputs_test.txt in a write way.
2. After we do a write operation using fputs() function by writing 3 different strings
3. Then the file is closed using the fclose function.

fprintf()Part:

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

OUTPUT:

1. In the above program we have created and opened a file called fprintf_test.txt in a write mode.
2. After a write operation is performed using fprintf() function by writing a string, so the file is airtight using the fclose function.

Reading data from a File

At that place are three different functions dedicated to reading data from a file

• fgetc(file_pointer): Information technology returns the next character from the file pointed to by the file pointer. When the terminate of the file has been reached, the EOF is sent back.
• fgets(buffer, north, file_pointer): It reads n-1 characters from the file and stores the cord in a buffer in which the Cypher graphic symbol '\0' is appended every bit the concluding character.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): Information technology is used to parse and analyze information. It reads characters from the file and assigns the input to a list of variable pointers variable_adresses using conversion specifiers. Go along in listen 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----\n");         fgets(buffer, fifty, file_pointer);         printf("%s\n", buffer);          printf("----read and parse data----\due north");         file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer         char str1[10], str2[2], str3[20], str4[2];         fscanf(file_pointer, "%s %s %due south %s", str1, str2, str3, str4);         printf("Read String1 |%s|\northward", str1);         printf("Read String2 |%due south|\northward", str2);         printf("Read String3 |%south|\northward", str3);         printf("Read String4 |%s|\n", str4);          printf("----read the unabridged file----\n");          file_pointer = fopen("fprintf_test.txt", "r"); //reset the arrow         while ((c = getc(file_pointer)) != EOF) printf("%c", c);          fclose(file_pointer);         return 0;     }

Result:

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

1. In the above program, nosotros have opened the file called "fprintf_test.txt" which was previously written using fprintf() part, and it contains "Learning C with Guru99" cord. We read information technology using the fgets() function which reads line by line where the buffer size must exist plenty to handle the unabridged line.
2. We reopen the file to reset the pointer file to betoken at the start of the file. Create various strings variables to handle each discussion separately. Print the variables to meet 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 signal at the beginning of the file. Read data and print it from the file character by character using getc() function until the EOF statement is encountered
4. After performing a reading functioning 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 character. These two functions are used to handle but a single character at a fourth dimension.

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

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

Output:

1. In the higher up program we take created and opened a file called demo in a write fashion.
2. After a write functioning is performed, then the file is closed using the fclose office.
3. We have once more opened a file which at present contains data in a reading mode. A while loop will execute until the eof is institute. Once the end of file is found the operation will exist terminated and data will exist displayed using printf part.
4. After performing a reading operation file is once again closed using the fclose function.

Summary

• A file is a infinite in a memory where data is stored.
• 'C' programming provides various functions to deal with a file.
• A mechanism of manipulating with the files is called as file management.
• A file must be opened earlier performing operations on information technology.
• A file tin can exist opened in a read, write or an append mode.
• Getc and putc functions are used to read and write a single character.
• The function fscanf() permits to read and parse data from a file
• We can read (using the getc role) an entire file past looping to cover all the file until the EOF is encountered
• We tin write to a file after creating its name, by using the part fprintf() and it must accept the newline grapheme at the finish of the cord text.

spaincreter.blogspot.com

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

Share this post