File Management in C. Console oriented Input/Output Console oriented – use terminal (keyboard/screen) scanf(“%d”,&i) – read data from keyboard printf(“%d”,i)

Slides:



Advertisements
Similar presentations
File Management in C. What is a File? A file is a collection of related data that a computers treats as a single unit. Computers store files to secondary.
Advertisements

Files in C Rohit Khokher.
BITS Pilani, Pilani Campus TA C252 Computer Programming - II Vikas Singh File Handling.
File Management in C. A file is a collection of related data that a computers treats as a single unit. File is a collection of data stored permanently.
Files in C Rohit Khokher. Files in C Real life situations involve large volume of data and in such cases, the console oriented I/O operations pose two.
Chapter 11: Data Files & File Processing In this chapter, you will learn about Files and streams Creating a sequential access file Reading data from a.
CSCI 171 Presentation 12 Files. Working with files File Streams – sequence of data that is connected with a specific file –Text Stream – Made up of lines.
Programming In C++ Spring Semester 2013 Lecture 10 Programming In C++, Lecture 10 By Umer Rana.
© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved Introduction Data files –Can be created, updated,
Chapter 11 C File Processing Acknowledgment The notes are adapted from those provided by Deitel & Associates, Inc. and Pearson Education Inc.
File I/O.
Command line arguments. – main can take two arguments conventionally called argc and argv. – Information regarding command line arguments are passed to.
Console and File I/O - Basics Rudra Dutta CSC Spring 2007, Section 001.
1 Homework Introduction to HW7 –Complexity similar to HW6 –Don’t wait until last minute to start on it File Access will be needed in HW8.
20/03/01 Sudeshna Sarkar, CSE, IIT Kharagpur1 File Handling in C Lecture 17c 20/3/01.
Lone Leth Thomsen Input / Output and Files. April 2006Basis-C-8/LL2 sprintf() and sscanf() The functions sprintf() and sscanf() are string versions of.
File Handling Spring 2013Programming and Data Structure1.
22. FILE INPUT/OUTPUT. File Pointers and Streams Declarations of functions that perform file I/O appear in. Each function requires a file pointer as a.
C Programming – Part 6 File Input and Output
 2007 Pearson Education, Inc. All rights reserved C File Processing.
1 Lecture09: File I/O 5/6/2013 Slides modified from Yin Lou, Cornell CS2022: Introduction to C.
Introduction to Programming Using C Files. 2 Contents Files Working with files Sequential files Records.
File IO and command line input CSE 2451 Rong Shi.
CSEB114: Principle of programming Chapter 11: Data Files & File Processing.
ECE 103 Engineering Programming Chapter 44 File I/O Herbert G. Mayer, PSU CS Status 6/4/2014 Initial content copied verbatim from ECE 103 material developed.
1 File Handling. 2 Storage seen so far All variables stored in memory Problem: the contents of memory are wiped out when the computer is powered off Example:
1 Lecture09: File I/O 11/19/2012 Slides modified from Yin Lou, Cornell CS2022: Introduction to C.
Chapter 11: Data Files and File Processing Files and streams Creating a sequential access file Reading data from a sequential access file Using fgetc()
Chapter 7 : File Processing1 File-Oriented Input & Output CHAPTER 7.
1 CHAPTER6 CHAPTER 6. Objectives: You’ll learn about;  Introduction  Files and streams  Creating a sequential access file  Reading data from a sequential.
24-2 Perform File I/O using file pointers FILE * data-type Opening and closing files Character Input and Output String Input and Output Related Chapter:
GAME203 – C Files stdio.h C standard Input/Output “getchar()”
Learners Support Publications Working with Files.
Files A collection of related data treated as a unit. Two types Text
 2007 Pearson Education, Inc. All rights reserved. 1 C File Processing.
Computer Science: A Structured Programming Approach Using C1 Objectives ❏ To understand the basic properties and characteristics of external files ❏ To.
Files. FILE * u In C, we use a FILE * data type to access files. u FILE * is defined in /usr/include/stdio.h u An example: #include int main() { FILE.
Lecture 20: C File Processing. Why Using Files? Storage of data in variables and arrays is temporary Data lost when a program terminates. Files are used.
Connecting to Files In order to read or write to a file, we need to make a connection to it. There are several functions for doing this. fopen() – makes.
C Programming Day 2. 2 Copyright © 2005, Infosys Technologies Ltd ER/CORP/CRS/LA07/003 Version No. 1.0 Union –mechanism to create user defined data types.
 2007 Pearson Education, Inc. All rights reserved C File Processing.
6/9/2016Course material created by D. Woit 1 CPS 393 Introduction to Unix and C START OF WEEK 10 (C-4)
Chapter 7 Text Input/Output Objectives
Chapter 7 Text Input/Output Objectives
RECURSION Recursion is a process where a function calls itself. main()
Chapter 22 – part a Stream refer to any source of input or any destination for output. Many small programs, obtain all their input from one stream usually.
Chapter 7 Text Input/Output Objectives
File Access (7.5) CSE 2031 Fall July 2018.
File I/O.
UNIT 5 POINTERS AND FILES
Plan for the Day: I/O (beyond scanf and printf)
CS111 Computer Programming
CSE1320 Files in C Dr. Sajib Datta
File Input/Output.
CSE1320 Files in C Dr. Sajib Datta
File Management in C.
Files I/O, Streams, I/O Redirection, Reading with fscanf
CSE1320 Files in C Dr. Sajib Datta
CSC215 Lecture Input and Output.
Programming and Data Structure
Text and Binary File Processing
File Input and Output.
File Handling.
Fundamental of Programming (C)
File Handling in C.
Chapter 5 File Handling in C
Chapter 12: File I/O.
ETE 132 Lecture 8 By Munirul Haque.
CSc 352 File I/O Saumya Debray Dept. of Computer Science
Professor Jodi Neely-Ritz University of Florida
Presentation transcript:

File Management in C

Console oriented Input/Output Console oriented – use terminal (keyboard/screen) scanf(“%d”,&i) – read data from keyboard printf(“%d”,i) – print data to monitor Suitable for small volumes of data Data lost when program terminated

Real-life applications Large data volumes E.g. physical experiments (CERN collider), human genome, population records etc. Need for flexible approach to store/retrieve data Concept of files

Files File – place on disc where group of related data is stored – E.g. your C programs, executables High-level programming languages support file operations – Naming – Opening – Reading – Writing – Closing

Defining and opening file To store data file in secondary memory (disc) must specify to OS – Filename (e.g. sort.c, input.data) – Data structure (e.g. FILE) – Purpose (e.g. reading, writing, appending)

Filename String of characters that make up a valid filename for OS May contain two parts – Primary – Optional period with extension Examples: a.out, prog.c, temp, text.out

General format for opening file fp – contains all information about file – Communication link between system and program Mode can be – r open file for reading only – w open file for writing only – a open file for appending (adding) data FILE *fp; /*variable fp is pointer to type FILE*/ fp = fopen(“filename”, “mode”); /*opens file with name filename, assigns identifier to fp */

Different modes Writing mode – if file already exists then contents are deleted, – else new file with specified name created Appending mode – if file already exists then file opened with contents safe – else new file created Reading mode – if file already exists then opened with contents safe – else error occurs. FILE *p1, *p2; p1 = fopen(“data”,”r”); p2= fopen(“results”, w”);

Additional modes r+ open to beginning for both reading/writing w+ same as w except both for reading and writing a+ same as ‘a’ except both for reading and writing

Closing a file File must be closed as soon as all operations on it completed Ensures – All outstanding information associated with file flushed out from buffers – All links to file broken – Accidental misuse of file prevented If want to change mode of file, then first close and open again

Closing a file pointer can be reused after closing Syntax: fclose(file_pointer); Example: FILE *p1, *p2; p1 = fopen(“INPUT.txt”, “r”); p2 =fopen(“OUTPUT.txt”, “w”); …….. fclose(p1); fclose(p2);

Input/Output operations on files C provides several different functions for reading/writing getc() – read a character putc() – write a character fprintf() – write set of data values fscanf() – read set of data values getw() – read integer putw() – write integer

getc() and putc() handle one character at a time like getchar() and putchar() syntax: putc(c,fp1); – c : a character variable – fp1 : pointer to file opened with mode w syntax: c = getc(fp2); – c : a character variable – fp2 : pointer to file opened with mode r file pointer moves by one character position after every getc() and putc() getc() returns end-of-file marker EOF when file end reached

Program to read/write using getc/putc #include main() {FILE *fp1; char c; f1= fopen(“INPUT”, “w”); /* open file for writing */ while((c=getchar()) != EOF) /*get char from keyboard until CTL-Z*/ putc(c,f1); /*write a character to INPUT */ fclose(f1); /* close INPUT */ f1=fopen(“INPUT”, “r”); /* reopen file */ while((c=getc(f1))!=EOF) /*read character from file INPUT*/ printf(“%c”, c);/* print character to screen */ fclose(f1); } /*end main */

fscanf() and fprintf() similar to scanf() and printf() in addition provide file-pointer given the following – file-pointer f1 (points to file opened in write mode) – file-pointer f2 (points to file opened in read mode) – integer variable i – float variable f Example: fprintf(f1, “%d %f\n”, i, f); fprintf(stdout, “%f \n”, f); /*note: stdout refers to screen */ fscanf(f2, “%d %f”, &i, &f); fscanf returns EOF when end-of-file reached

getw() and putw() handle one integer at a time syntax: putw(i,fp1); – i : an integer variable – fp1 : pointer to file ipened with mode w syntax: i = getw(fp2); – i : an integer variable – fp2 : pointer to file opened with mode r file pointer moves by one integer position, data stored in binary format native to local system getw() returns end-of-file marker EOF when file end reached

C program using getw, putw,fscanf, fprintf #include main() { int i,sum1=0; FILE *f1; /* open files */ f1 = fopen("int_data.bin","w"); /* write integers to files in binary and text format*/ for(i=10;i<15;i++) putw(i,f1); fclose(f1); f1 = fopen("int_data.bin","r"); while((i=getw(f1))!=EOF) { sum1+=i; printf("binary file: i=%d\n",i); } /* end while getw */ printf("binary sum=%d,sum1); fclose(f1); } #include main() { int i, sum2=0; FILE *f2; /* open files */ f2 = fopen("int_data.txt","w"); /* write integers to files in binary and text format*/ for(i=10;i<15;i++) printf(f2,"%d\n",i); fclose(f2); f2 = fopen("int_data.txt","r"); while(fscanf(f2,"%d",&i)!=EOF) { sum2+=i; printf("text file: i=%d\n",i); } /*end while fscanf*/ printf("text sum=%d\n",sum2); fclose(f2); }

On execution of previous Programs $./a.out binary file: i=10 binary file: i=11 binary file: i=12 binary file: i=13 binary file: i=14 binary sum=60, $ cat int_data.txt $./a.out text file: i=10 text file: i=11 text file: i=12 text file: i=13 text file: i=14 text sum=60 $ more int_data.bin $

Errors that occur during I/O Typical errors that occur – trying to read beyond end-of-file – trying to use a file that has not been opened – perform operation on file not permitted by ‘fopen’ mode – open file with invalid filename – write to write-protected file

Error handling given file-pointer, check if EOF reached, errors while handling file, problems opening file etc. check if EOF reached: feof() feof() takes file-pointer as input, returns nonzero if all data read and zero otherwise if(feof(fp)) printf(“End of data\n”); ferror() takes file-pointer as input, returns nonzero integer if error detected else returns zero if(ferror(fp) !=0) printf(“An error has occurred\n”);

Error while opening file if file cannot be opened then fopen returns a NULL pointer Good practice to check if pointer is NULL before proceeding fp = fopen(“input.dat”, “r”); if (fp == NULL) printf(“File could not be opened \n ”);

Random access to files how to jump to a given position (byte number) in a file without reading all the previous data? fseek (file-pointer, offset, position); position: 0 (beginning), 1 (current), 2 (end) offset: number of locations to move from position Example: fseek(fp,-m, 1); /* move back by m bytes from current position */ fseek(fp,m,0); /* move to (m+1)th byte in file */ fseek(fp, -10, 2); /* what is this? */ ftell(fp) returns current byte position in file rewind(fp) resets position to start of file

Command line arguments can give input to C program from command line E.g. > prog.c 10 name1 name2 …. how to use these arguments? main ( int argc, char *argv[] ) argc – gives a count of number of arguments (including program name) char *argv[] defines an array of pointers to character (or array of strings) argv[0] – program name argv[1] to argv[argc -1] give the other arguments as strings

Example args.c $ cc args.c -o args.out $./args.out 2 join leave 6 6 leave join 2./args.out $ #include main(int argc,char *argv[]) { while(argc>0) /* print out all arguments in reverse order*/ { printf("%s\n",argv[argc-1]); argc--; }