Chapter 2.

Fundamental File
Processing Operations
Kim Joung-Joon
Database Lab.

jjkim9@db.konkuk.ac.kr

Chapter Objectives

Describe the process of linking a logical file within a program to an

actual physical file of device
Describe the procedures used to create, open and close files
Introduce the C++ input and output classes
Explain the use of overloading in C++
Describe the procedures used for reading from and writing to files
Introduce the concept of position within a file and describe
procedures for seeking different positions
Provide an introduction to the organization of hierarchical file
systems
Present the Unix view of a file and describe Unix file operations and
commands based on this view

File Structures (2)

Konkuk University (DB Lab.)

Chapter Outline
2.1 Physical Files and Logical Files
2.2 Opening Files
2.2 Closing Files
2.4 Reading and Writing
2.5 Seeking
2.6 Special Characters in Files
2.7 The Unix Directory Structures
2.8 Physical Devices and Logical Files
2.9 File-Related Header Files
2.10 Unix File System Commands
File Structures (2)

Konkuk University (DB Lab.)

2.1 Physical Files and Logical Files

File

Physical file

a particular collection of bytes

a file on a disk or tape

Logical file

a file used inside the program

(ex) select inp_file assign to myfile.dat. : Cobol

assign (inp_file, 'myfile.dat') : Turbo Pascal
logical file physical file
File Structures (2)

Konkuk University (DB Lab.)

2.1 Physical Files and Logical Files

File Structures (2)

Konkuk University (DB Lab.)

2.2 Opening Files

Two options
(1) open an existing file

position at the beginning of the file and ready to start reading

and writing

(2) create a new file

ready for use after creation

C++ and C (fcntl.h)

fd = open(filename, flags [, pmode]); => pp.17-18

(ex) fd = open(filename, O_RDWR | O_CREAT, 0751);

fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0751);
fd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0751);
File Structures (2)

Konkuk University (DB Lab.)

2.3 Closing Files

Closing a file
the logical name or file descriptor is available for use with
another file (i.e., breaks the link)
ensure that everything has been written to the file
(i.e., the buffer for the file has been flushed of data and
everything we have written has been sent to the file)
automatically closed by OS when a program terminates
normally
(=> for protection against data loss and for reuse of logical
filenames)

File Structures (2)

Konkuk University (DB Lab.)

2.4 Reading and Writing (1/4)

Read and Write Functions

Before reading or writing, we must have already opened the

file.
low level read or write
READ (Source_file,
Destination_addr,
Size)
logical file
name
WRITE(Destination_file,

File Structures (2)

first addr. of the

memory block
Source_addr,

Konkuk University (DB Lab.)

byte count

Size)

2.4 Reading and Writing (2/4)

Files with-C Streams & C++ Stream Classes

stream : a file or some other source or consumer of file
(1) C Streams or C input/output

use the standard C functions in stdio.h

stdio.h contains definitions of the types & the operations on C streams
stdio & stdout : standard input and output streams
file = fopen(filename, type);=> pp.21-22
fread, fget, fwrite, fput, fscanf, fprintf

(2) C++ stream classes

use the stream classes of iostream.h and fstream.h

cin, cout : predefined stream objects for the standard input & standard
output files
fstream : class for access to files has two constructors and methods, open,

>>(extraction) and <<(insertion) : overloaded for input and output

read, write

File Structures (2)

Konkuk University (DB Lab.)

2.4 Reading and Writing (3/4)

Programs in C++ to Display the Contents of a File

Display a prompt for the name of the input file
Read the users response from the keyboard into a variable
called filename
3. Open the file for input
4. While there are still characters to be read from the input file
1.
2.

1.
2.

5.

Read a character from the file

Write the character to the terminal screen

Close the input file

Ex)
Figure 2.2 : using C streams
Figure 2.3 : using C++ stream classes
=> See Appendix D

File Structures (2)

Konkuk University (DB Lab.)

10

2.4 Reading and Writing (4/4)

Detecting End-of-file

fread call returns the 0 of elements read

C++

use the function fail to check end-of-file

File Structures (2)

Konkuk University (DB Lab.)

11

2.5 Seeking (1/3)

Seeking

to control the movement of the read/write pointer

Seek (Source_file, Offset)

Source_file : logical file name

Offset : the # of positions from the start of the file

(ex) Seek(data, 373)

move directly from the origin to the 373 position

File Structures (2)

Konkuk University (DB Lab.)

12

2.5 Seeking (2/3)

Seeking with C Streams

pos = fseek(fd, byte-offset, origin)

long integer

0 :
1 :
2 :

to set the read/write pointer to any byte in a file

(ex) pos = fseek (fd, 373, 0);

File Structures (2)

Konkuk University (DB Lab.)

13

2.5 Seeking (3/3)

Seeking with C++ Stream Classes

almost exactly the same as in C streams
Two syntactic differences
(1) an object of fstream has two file pointers, get pointer and put
pointer
=>seekg for the get pointer and seekp for the put pointer
(2) seek operations are methods of the stream classes
=>file.seekg(byte_offset, origin)
file.seekp(byte_offset, origin)

where origin = ios::beg, ios::cur, and ios::end

(ex) file.seekg(373, ios::beg);

file.seekp(373, ios::beg);
File Structures (2)

Konkuk University (DB Lab.)

14

2.7 The UNIX Directory Structure (1/2)

UNIX file system

a tree-structured organization with two kinds of files ( i.e.,

regular files(programs and data) and directories)

devices such as tape or disk drivers are also files (in dev
directory)

to indicate the root directory

to separate directory names from the file name

absolute pathname and relative pathname for file identification

current directory : .
parent directory : ..

File Structures (2)

Konkuk University (DB Lab.)

15

2.7 The UNIX Directory Structure (2/2)

/ (root)

bin

usr
bin

lib

usr6
lib

dev

mydir

adb cc yacc

console

kbd

TAPE

libdf.a
libc.a libm.a

File Structures (2)

addr

Konkuk University (DB Lab.)

DF

16

2.8 Physical Devices and Logical Files

Physical Devices as Files

file in UNIX

a sequence of bytes ( => very few operations )

magnetic disk and devices like the keyboard and the
console are also files (/dev/kbd, /dev/console)
represented logically by an integer (file descriptor)

File Structures (2)

Konkuk University (DB Lab.)

17

2.8 Physical Devices and Logical Files

The Console, the Keyboard, and Standard Error

defined in stdio.h

Stdin (standard input) : keyboard

Stdout(standard output): console

Stderr(standard error) : console

Read and write

read ... gets <--- stdin

write ... printf ---> stdout

File Structures (2)

Konkuk University (DB Lab.)

18

2.8 Physical Devices and Logical Files

I/O Redirection and Pipes

for switching between standard I/O (stdin and stdout) and

regular file I/O
I/O redirection

to specify at execution time alternate files for input or output

< file ( redirect stdin to "file" )
> file ( redirect stdout to "file" )
(ex) list > myfile

Pipe

to use the output of a program as input to another program

without using an intermediate file
program1 | program2
any stdout output of program1 => any stdin input to
program2
(ex) list | sort

File Structures (2)

Konkuk University (DB Lab.)

19

2.9 File-Related Header Files

Header files ( /usr/include )

have special names and values

C streams : stdio.h

C++ streams : iostream.h and fstream.h

Unix operations : fcntl.h and file.h

EOF, stdin, stdout, stderr : stdio.h

O_RDONLY, O_WRONLY, O_RDWR : file.h

File Structures (2)

Konkuk University (DB Lab.)

20

2.10 Unix File System Commands

Unix Commands

cat filenames

tail filenames

cp file1 file2
rm filenames
ls
rmdir name

mv file1 file2
chmod mode filename
mkdir name

=> Consult a Unix manual for more information

File Structures (2)

Konkuk University (DB Lab.)

21

A.1 File I/O in Pascal (1/2)

included in language definition

provide high-level access to reading/writing
in C, a file is a sequence of bytes, but
in Pascal, a file is a sequence of records

File Structures (2)

Konkuk University (DB Lab.)

22

A.2 File I/O in Pascal (2/2)

File I/O functions

assign(input_file, myfile.dat);
// associate between a logical file and a physical file
reset(input_file); // open existing file
rewrite(input_file);
// create new file
append(input_file);
// open to add data to existing file
read(input_file, var);
// read from file to variable
readln(input_file, var);
// read from file to variable
write(input_file, var);
// write from variable to file
writeln(input_file, var);
// write from variable to file
close(input_file); // close file

File Structures (2)

Konkuk University (DB Lab.)

23

A.3 File I/O in C

Low-level I/O
UNIX system calls

fd1 = open(filename1, rwmode);

fd2 = open(filename2, rwmode);
read(fd1, buf, n);
write(fd2, buf, n);
lseek(fd1, offset, origin);
close(fd1);
close(fd2);

File Structures (2)

Konkuk University (DB Lab.)

24

A.4 <stdio.h>

fp = fopen(s, mode)
/* open file s; mode r, w, a for read, write, append (returns NULL for error) */
c = getc(fp)
/* get character; getchar() is getc(stdin) */
putc(c, fp)
/* put character; putchar(c) is putc(c, stdout) */
ungetc(c, fp)
/* put character back on input file fp; at most 1 char can be pushed back at one time */
scanf(fmt, a1, ....)
/* read characters from stdin into a1, ... according to fmt. Each ai must be a pointer. Returns EOF or
number of fields converted */
fscanf(fp, .....)
/* read from file fp */
printf(fmt, a1, ....)
/* format a1, ... according to fmt, print on stdout */
fprintf(fp, ....)
/* print .... on file fp */
fgets(s, n, fp)
/* read at most n characters into s from fp. Returns NULL at end of file */
fputs(s, fp)
/* print string s on file fp */
fflush(fp)
/* flush any buffered output on file fp */
fclose(fp)
/* close file fp */

File Structures (2)

Konkuk University (DB Lab.)

25

A.5 File I/O in C++

#include <fstream.h>

File Stream: fstream, ifstream, ofstream

(ex) ifstream f1(input.fil);
ofstream f2(output.fil, ios::out|ios::nocreat);
fstream f3(inout.fil, ios::in|ios::out);
f1.get(ch);
f1.eof();
f2.put(ch);
f2.bad();
f1.seekg(); f2.seekp();
f3.close();

File Structures (2)

Konkuk University (DB Lab.)

26

A.6 <iostream.h> (1/3)

class ios

class istream: virtual public ios

class ostream: virtual public ios

class iostream: public istream, public ostream

Class Hierarchy
File Structures (2)

Konkuk University (DB Lab.)

27

A.7 <iostream.h> (2/3)

class ostream: virtual public ios
{ public:
ostream& put(char);
ostream& write(char*, int);
ostream& seekp(int);
ostream& operator<<(char);
ostream& operator<<(int);
ostream& operator<<(char*);
ostream& operator<<(long);
ostream& operator<<(short);
ostream& operator<<(float);
..............
};

File Structures (2)

class istream: virtual public ios

{ public:
istream& get(char*, int, char = n);
istream& get(char);
istream& read(char*, int);
istream& gets(char**, char = n);
istream& seekg(int);
istream& operator>>(char&);
istream& operator>>(int&);
istream& operator>>(char*);
istream& operator>>(long&);
...............
};

Konkuk University (DB Lab.)

28

A.8 <iostream.h> (3/3)

class iostream: public istream, public ostream
{
public:
iostream( ) { }
};

File Structures (2)

Konkuk University (DB Lab.)

29

A.9 Copy Program in C++ (1/2)

#include <fstream.h>
#include <libc.h>
void error(char *s, char *s2 = ){
cerr << s << << s2 << n;
exit(1);
}
int main(int argc, char *argv[])
{
if( argc != 3) error(wrong number of arguments);
ifstream src(argv[1]); //input file stream
if (!src) error(cannot open input file, argv[1]);

File Structures (2)

Konkuk University (DB Lab.)

30

A.9 Copy Program in C++ (2/2)

ofstream dest(argv[2]); //output file stream
if(!dest) error(cannot open output file, argv[2]);
char ch;
while( src.get(ch) ) dest.put(ch);
if(!src.eof() || dest.bad())
error(something strange happened !);
return 0;
}

File Structures (2)

Konkuk University (DB Lab.)

31