How To Read In A File With Different Types Of Data In C++

C File management

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

Creation of a file
Opening a file
Reading a file
Writing to a file
Closing a file

Post-obit are the nigh important file management functions available in 'C,'

part	purpose
fopen ()	Creating a file or opening an existing file
fclose ()	Closing a file
fprintf ()	Writing a block of data to a file
fscanf ()	Reading a block information from a file
getc ()	Reads a unmarried character from a file
putc ()	Writes a single character 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 arrow
rewind ()	Sets the file arrow at the starting time of a file

In this tutorial, you will larn-

How to Create a File
How to Close a file:
Writing to a File
fputc() Part:
fputs () Function:
fprintf()Function:
Reading data 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 start step is to create a file. A file is nothing but space in a retention where data is stored.

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

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

In the to 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 organisation, then it is created and and then opened.
If a file is already present on the system, so it is directly opened using this office.

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

Whenever y'all open or create a file, you have to specify what you are going to practice 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 lot desire 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, then no information is deleted if a file is already present on a system.
w	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 present on a organization, then all the data inside the file is truncated, and information technology is opened for writing purposes.
a	Open a file in append style. If a file is in append mode, then the file is opened. The content inside the file doesn't change.
r+	open up for reading and writing from starting time
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.

Example:

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

Output:

File is created in the same folder where y'all have saved your code.

You tin specify the path where yous want to create your file

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

How to Close a file

1 should always shut a file whenever the operations on file are over. It means 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 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 arrow as an argument. The file associated with the file pointer is then airtight with the aid of fclose function. It returns 0 if close was successful and EOF (end of file) if at that place is an mistake has occurred while file closing.

After closing the file, the same file pointer can as well exist used with other files.

In 'C' programming, files are automatically close when the program is terminated. Closing a file manually past writing fclose function is a good programming exercise.

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): Information technology 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 string to the file pointed to by file_pointer. The string can optionally include format specifiers and a list of variables variable_lists.

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

fputc() Function:

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

Output:

The above programme writes a single grapheme into the fputc_test.txt file until it reaches the adjacent 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.

In the in a higher place programme, we have created and opened a file called fputc_test.txt in a write mode and declare our string which will exist written into the file.
We do a character past character write functioning using for loop and put each grapheme in our file until the "\northward" graphic symbol is encountered then the file is closed using the fclose function.

fputs () Role:

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

OUTPUT:

In the above program, we accept created and opened a file called fputs_test.txt in a write mode.
Later on we practise a write functioning using fputs() function by writing three dissimilar strings
And then the file is airtight using the fclose function.

fprintf()Function:

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

OUTPUT:

In the above programme we have created and opened a file called fprintf_test.txt in a write mode.
Later a write functioning is performed using fprintf() function by writing a string, then the file is closed using the fclose function.

Reading data from a File

There are three dissimilar functions defended to reading data from a file

fgetc(file_pointer): It returns the adjacent character from the file pointed to by the file pointer. When the finish of the file has been reached, the EOF is sent back.
fgets(buffer, northward, file_pointer): It reads due north-one characters from the file and stores the string in a buffer in which the Zip character '\0' is appended every bit the last graphic symbol.
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. Keep in heed that as with scanf, fscanf stops reading a string when space or newline is encountered.

The post-obit 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, 50, file_pointer);         printf("%due south\n", buffer);          printf("----read and parse information----\n");         file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer         char str1[x], str2[2], str3[20], str4[2];         fscanf(file_pointer, "%s %s %s %due south", str1, str2, str3, str4);         printf("Read String1 |%s|\n", str1);         printf("Read String2 |%s|\n", str2);         printf("Read String3 |%due south|\n", str3);         printf("Read String4 |%s|\north", 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);         return 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 entire file---- Learning C with Guru99

In the above program, we have opened the file called "fprintf_test.txt" which was previously written using fprintf() function, and it contains "Learning C with Guru99" cord. We read information technology using the fgets() part which reads line by line where the buffer size must exist enough to handle the entire line.
We reopen the file to reset the pointer file to point at the outset 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.
Reopen the file to reset the arrow file to point at the beginning of the file. Read data and impress it from the file grapheme by graphic symbol using getc() function until the EOF statement is encountered
Later on performing a reading functioning file using different 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 go character, and putc stands for put graphic symbol. These two functions are used to handle simply a single character at a fourth dimension.

Post-obit programme demonstrates the file handling functions in 'C' programming:

#include <stdio.h> int main() {         FILE * fp;         char c;         printf("File Treatment\northward");         //open a file         fp = fopen("demo.txt", "w");         //writing operation         while ((c = getchar()) != EOF) {             putc(c, fp);         }         //close 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:

In the above program nosotros take created and opened a file chosen demo in a write manner.
Afterwards a write operation is performed, and so the file is closed using the fclose office.
We accept once again opened a file which now contains information in a reading mode. A while loop volition execute until the eof is found. One time the end of file is found the operation will be terminated and information volition be displayed using printf part.
After performing a reading performance 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 deal with a file.
A machinery of manipulating with the files is called every bit file direction.
A file must be opened earlier performing operations on it.
A file tin can be opened in a read, write or an suspend way.
Getc and putc functions are used to read and write a single character.
The part fscanf() permits to read and parse data from a file
Nosotros can read (using the getc function) an entire file past looping to cover all the file until the EOF is encountered
We can write to a file after creating its proper name, past using the function fprintf() and information technology must take the newline character at the finish of the cord text.