Create a Function , Readdata() That Reads From an Input File the Following Data C++

C File management

A File can be used to store a large volume 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

Post-obit are the most important 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 data from a file
getc ()	Reads a single character from a file
putc ()	Writes a unmarried 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 arrow to a specified location
ftell ()	Returns the electric current position of a file pointer
rewind ()	Sets the file pointer at the kickoff of a file

In this tutorial, you volition larn-

• How to Create a File
• How to Close a file:
• Writing to a File
• fputc() Function:
• fputs () Function:
• fprintf()Office:
• Reading data 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 first stride is to create a file. A file is nothing but infinite in a retentivity 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 above syntax, the file is a data construction which is divers in the standard library.

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

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

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

Whenever you open up or create a file, you have to specify what you are going to exercise 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 up a file for any of the beneath-given purposes. Following are the dissimilar 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 data is deleted if a file is already present on a organisation.
w	Open a file for writing. If a file is in writing fashion, then a new file is created if a file doesn't be at all. If a file is already nowadays on a system, and then all the information within the file is truncated, and it is opened for writing purposes.
a	Open a file in append mode. If a file is in append mode, then the file is opened. The content within the file doesn't alter.
r+	open for reading and writing from start
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 way are specified as strings hence they must ever exist enclosed within double quotes.

Case:

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

Output:

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

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

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

How to Close a file

Ane 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 adventitious damage to the file.

'C' provides the fclose function to perform file endmost 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 arrow as an argument. The file associated with the file pointer is then closed with the help of fclose function. It returns 0 if close was successful and EOF (end of file) if there is an mistake has occurred while file endmost.

After closing the file, the same file arrow can also exist used with other files.

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

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 grapheme 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): Information technology 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() Function:

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

Output:

The above program writes a unmarried character into the fputc_test.txt file until it reaches the next line symbol "\n" 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 higher up program, we accept created and opened a file called fputc_test.txt in a write fashion and declare our string which will be written into the file.
2. We do a character by character write operation using for loop and put each character in our file until the "\n" character is encountered then the file is closed using the fclose function.

fputs () Function:

#include <stdio.h> int primary() {         FILE * fp;         fp = fopen("fputs_test.txt", "w+");         fputs("This is Guru99 Tutorial on fputs,", fp);         fputs("We don't need to employ for loop\n", fp);         fputs("Easier than fputc office\n", 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 style.
2. Later nosotros exercise a write operation using fputs() function past writing three different strings
3. Then the file is closed using the fclose function.

fprintf()Function:

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

OUTPUT:

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

Reading data from a File

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

• fgetc(file_pointer): It returns the adjacent grapheme from the file pointed to by the file arrow. When the terminate of the file has been reached, the EOF is sent back.
• fgets(buffer, n, file_pointer): It reads 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. It reads characters from the file and assigns the input to a list of variable pointers variable_adresses using conversion specifiers. Keep in mind that equally with scanf, fscanf stops reading a cord 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, 50, file_pointer);         printf("%south\n", buffer);          printf("----read and parse data----\n");         file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer         char str1[ten], str2[two], str3[twenty], str4[2];         fscanf(file_pointer, "%s %southward %southward %south", str1, str2, str3, str4);         printf("Read String1 |%south|\n", str1);         printf("Read String2 |%s|\n", str2);         printf("Read String3 |%s|\n", str3);         printf("Read String4 |%s|\northward", str4);          printf("----read the entire file----\due north");          file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer         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 data---- Read String1 |Learning| Read String2 |C| Read String3 |with| Read String4 |Guru99| ----read the entire 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() function, and information technology contains "Learning C with Guru99" cord. We read it using the fgets() function which reads line past line where the buffer size must be enough to handle the entire line.
2. We reopen the file to reset the arrow file to point at the kickoff of the file. Create diverse strings variables to handle each word separately. Print the variables to see their contents. The fscanf() is mainly used to excerpt and parse data from a file.
3. Reopen the file to reset the pointer file to indicate at the showtime of the file. Read data and impress it from the file character by character using getc() part until the EOF statement is encountered
4. Afterward performing a reading operation 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 get character, and putc stands for put graphic symbol. These 2 functions are used to handle but a single character at a time.

Following programme demonstrates the file treatment functions in 'C' programming:

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

Output:

1. In the in a higher place plan we take created and opened a file chosen demo in a write mode.
2. Afterwards a write operation is performed, then the file is closed using the fclose part.
3. We have again opened a file which now contains information in a reading way. A while loop will execute until the eof is institute. In one case the end of file is found the operation will be terminated and data volition exist displayed using printf function.
4. After performing a reading functioning file is again closed using the fclose function.

Summary

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

aultonger1948.blogspot.com

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

Share this post