True/false: When a Piece of Data Is Read From a File, It Is Copied From the File Into the Program.

C File direction

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

Following are the most of import file management functions available in 'C,'

office	purpose
fopen ()	Creating a file or opening an existing file
fclose ()	Endmost a file
fprintf ()	Writing a block 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 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 pointer at the beginning of a file

In this tutorial, you lot will acquire-

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

How to Create a File

Whenever you lot want to work with a file, the kickoff 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", "fashion");          

In the above syntax, the file is a data construction 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 organization, then it is created and then opened.
• If a file is already present on the organization, then it is directly opened using this office.

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

Whenever you open or create a file, you take to specify what you are going to do with the file. A file in 'C' programming tin exist created or opened for reading/writing purposes. A way is used to specify whether you desire to open a file for whatsoever 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 Style	Description
r	Open up a file for reading. If a file is in reading mode, and then no data is deleted if a file is already present on a system.
westward	Open up 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 system, and so all the data inside the file is truncated, and information technology is opened for writing purposes.
a	Open a file in append manner. If a file is in append way, then the file is opened. The content inside the file doesn't change.
r+	open for reading and writing from beginning
west+	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 fashion are specified every bit strings hence they must ever exist enclosed within double quotes.

Example:

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

Output:

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

You lot can 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

I should always 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 function to perform file closing operation. The syntax of fclose is as follows,

fclose (file_pointer);          

Example:

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

The fclose function takes a file pointer equally an statement. The file associated with the file pointer is then airtight with the help of fclose part. Information technology returns 0 if close was successful and EOF (cease of file) if there is an mistake has occurred while file endmost.

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

In 'C' programming, files are automatically shut when the plan is terminated. Closing a file manually by writing fclose role is a good programming do.

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

#include <stdio.h> int principal() {         int i;         FILE * fptr;         char fn[50];         char str[] = "Guru99 Rocks\n";         fptr = fopen("fputc_test.txt", "w"); // "w" 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 "\northward" which indicates that the sentence was successfully written. The process is to accept each character of the array and write it into the file.

1. In the higher up plan, 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.
2. We do a grapheme by graphic symbol write operation using for loop and put each character in our file until the "\north" character is encountered then the file is airtight 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 apply for loop\n", fp);         fputs("Easier than fputc role\northward", fp);         fclose(fp);         return (0);     }

OUTPUT:

1. In the in a higher place program, we accept created and opened a file called fputs_test.txt in a write mode.
2. After we practice a write functioning using fputs() function by writing three different strings
3. So the file is airtight using the fclose role.

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 in a higher place program we have created and opened a file chosen fprintf_test.txt in a write mode.
2. Later on a write functioning is performed using fprintf() function past writing a cord, then the file is closed using the fclose part.

Reading data from a File

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

• fgetc(file_pointer): It returns the next 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 n-ane characters from the file and stores the cord in a buffer in which the NULL graphic symbol '\0' is appended equally the last character.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): It is used to parse and analyze data. It reads characters from the file and assigns the input to a listing of variable pointers variable_adresses using conversion specifiers. Keep 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----\n");         fgets(buffer, 50, file_pointer);         printf("%s\due north", buffer);          printf("----read and parse data----\northward");         file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer         char str1[x], str2[2], str3[twenty], str4[2];         fscanf(file_pointer, "%s %s %s %s", str1, str2, str3, str4);         printf("Read String1 |%s|\n", str1);         printf("Read String2 |%s|\n", str2);         printf("Read String3 |%s|\n", str3);         printf("Read String4 |%s|\n", 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;     }

Upshot:

----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 program, we have opened the file chosen "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 first 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 excerpt and parse information from a file.
3. Reopen the file to reset the pointer file to betoken at the beginning of the file. Read information and print it from the file character by character using getc() function until the EOF statement is encountered
4. Later performing a reading operation file using different variants, we once more 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 grapheme at a time.

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

#include <stdio.h> int primary() {         FILE * fp;         char c;         printf("File Handling\n");         //open a file         fp = fopen("demo.txt", "due west");         //writing functioning         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 above program nosotros take created and opened a file called demo in a write way.
2. Afterwards a write operation is performed, then the file is closed using the fclose role.
3. We have again opened a file which now contains data in a reading mode. A while loop will execute until the eof is found. Once the cease of file is found the operation will be terminated and data will exist displayed using printf function.
4. Subsequently performing a reading operation file is again closed using the fclose office.

Summary

• A file is a space 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 chosen as file management.
• A file must be opened earlier performing operations on information technology.
• A file can be opened in a read, write or an append fashion.
• 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 by looping to comprehend all the file until the EOF is encountered
• We can write to a file afterward creating its name, by using the function fprintf() and it must accept the newline character at the end of the string text.

jacobsenthervild1986.blogspot.com

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

Share this post