C++ How to Read in a Text Files

C File management

A File can be used to store a big volume of persistent information. Similar 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

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

office	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 cake data from a file
getc ()	Reads a single grapheme from a file
putc ()	Writes a unmarried 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 arrow to a specified location
ftell ()	Returns the electric current position of a file pointer
rewind ()	Sets the file arrow at the beginning of a file

In this tutorial, y'all will learn-

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

How to Create a File

Whenever you want to piece of 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' programme post-obit syntax is used,

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

In the in a higher place syntax, the file is a data structure which is defined in the standard library.

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

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

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

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

File Mode	Clarification
r	Open a file for reading. If a file is in reading mode, so no data is deleted if a file is already present on a system.
due west	Open a file for writing. If a file is in writing mode, then a new file is created if a file doesn't exist at all. If a file is already nowadays on a system, and then all the information inside the file is truncated, and it is opened for writing purposes.
a	Open up a file in suspend mode. If a file is in append fashion, then the file is opened. The content within the file doesn't change.
r+	open for reading and writing from commencement
w+	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 as strings hence they must always exist enclosed within double quotes.

Case:

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

Output:

File is created in the aforementioned folder where you lot have saved your code.

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

#include <stdio.h> int master() { 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. Information technology means the contents and links to the file are terminated. This prevents accidental impairment 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 function takes a file pointer as an argument. The file associated with the file arrow is and so closed with the help of fclose role. Information technology returns 0 if close was successful and EOF (end of file) if there is an error has occurred while file closing.

After closing the file, the same file pointer tin can too be used with other files.

In 'C' programming, files are automatically close when the plan is terminated. Endmost a file manually past writing fclose function is a good programming practice.

Writing to a File

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

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

• fputc(char, file_pointer): Information technology writes a character to the file pointed to past 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 string to the file pointed to by file_pointer. The string tin can optionally include format specifiers and a list of variables variable_lists.

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

fputc() Role:

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

Output:

The above program writes a single character into the fputc_test.txt file until it reaches the next line symbol "\north" which indicates that the judgement was successfully written. The process is to take each character of the array and write it into the file.

1. In the above program, we take created and opened a file called fputc_test.txt in a write manner and declare our string which will exist written into the file.
2. We do a character by character write operation using for loop and put each grapheme in our file until the "\n" character is encountered 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 utilize for loop\n", fp);         fputs("Easier than fputc part\northward", fp);         fclose(fp);         return (0);     }

OUTPUT:

1. In the above program, nosotros take created and opened a file called fputs_test.txt in a write mode.
2. After nosotros exercise a write operation using fputs() part by writing three different strings
3. So the file is closed using the fclose function.

fprintf()Function:

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

OUTPUT:

1. In the above program nosotros accept created and opened a file called fprintf_test.txt in a write mode.
2. After a write operation is performed using fprintf() part past writing a string, then the file is closed using the fclose office.

Reading data from a File

There are three unlike functions dedicated to reading data from a file

• fgetc(file_pointer): It returns the side by side character from the file pointed to by the file pointer. When the end of the file has been reached, the EOF is sent back.
• fgets(buffer, n, file_pointer): It reads north-1 characters from the file and stores the string in a buffer in which the Nothing graphic symbol '\0' is appended as the concluding 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 along in mind that equally with scanf, fscanf stops reading a string when infinite or newline is encountered.

The post-obit plan demonstrates reading from fputs_test.txt file using fgets(),fscanf() and fgetc () functions respectively :

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

Upshot:

----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 entire file---- Learning C with Guru99

1. In the above program, we accept opened the file called "fprintf_test.txt" which was previously written using fprintf() function, and information technology contains "Learning C with Guru99" string. We read it using the fgets() function which reads line by line where the buffer size must be enough to handle the entire line.
2. Nosotros reopen the file to reset the arrow file to point at the beginning of the file. Create diverse strings variables to handle each give-and-take separately. Impress 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 betoken at the get-go of the file. Read data and impress it from the file character by graphic symbol using getc() function until the EOF argument is encountered
4. After performing a reading operation file using different variants, we once more closed the file using the fclose office.

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 just a single character at a time.

Post-obit program demonstrates the file treatment functions in 'C' programming:

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

Output:

1. In the above program we have created and opened a file called demo in a write mode.
2. Subsequently a write operation is performed, and so the file is closed using the fclose part.
3. We have once more opened a file which now contains data in a reading mode. A while loop will execute until the eof is establish. Once the end of file is constitute the operation will be terminated and data volition be displayed using printf function.
4. Afterwards performing a reading functioning file is again airtight using the fclose role.

Summary

• A file is a space in a retentivity where data is stored.
• 'C' programming provides diverse functions to deal with a file.
• A mechanism of manipulating with the files is called equally file direction.
• A file must be opened earlier performing operations on information technology.
• A file can exist opened in a read, write or an suspend manner.
• Getc and putc functions are used to read and write a unmarried character.
• The role fscanf() permits to read and parse information from a file
• Nosotros can read (using the getc part) an entire file by looping to cover all the file until the EOF is encountered
• We can write to a file later on creating its proper noun, by using the part fprintf() and it must have the newline character at the finish of the cord text.

saultersmurst1985.blogspot.com

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

Share this post