POINTERS AND FILES

INTRODUCTION
● Every variable in C has a name and a value associated with it. When a variable is declared, a specific block
of memory within the computer is allocated to hold the value of that variable. The size of the allocated block
depends on the type of the data.
int x = 10;
● When this statement executes, the compiler sets aside 2 bytes of memory to hold the value 10. It also sets
up a symbol table in which it adds the symbol x and the relative address in memory where those 2 bytes
were set aside.
● Thus, every variable in C has a value and an also a memory location (commonly known as address)
associated with it. Some texts use the term rvalue and lvalue for the value and the address of the variable
respectively.
● The rvalue appears on the right side of the assignment statement and cannot be used on the left side of the

assignment statement. Therefore, writing 10 = k; is illegal.

 DECLARING POINTER VARIABLES
● Actually pointers are nothing but memory addresses.
● A pointer is a variable that contains the memory location of another variable.
● The general syntax of declaring pointer variable is
data_type *ptr_name;
Here, data_type is the data type of the value that the pointer will point to. For example:
int *pnum; char *pch; float *pfnum;
int x= 10;
int *ptr = &x;
The '*' informs the compiler that ptr is a pointer variable and the int specifies that it will store the
address of an integer variable.
The & operator retrieves the lvalue (address) of x, and copies that to the contents of the pointer
ptr.
 DE-REFERENCING A POINTER VARIABLE
● We can "dereference" a pointer, i.e. refer to the value of the variable to which it points by using
unary '*' operator as in *ptr. That is, *ptr = 10, since 10 is value of x.
#include<stdio.h>
int main()
{
int num, *pnum;
pnum = &num;
printf(“\n Enter the number : “);
scanf(“%d”, &num);
printf(“\n The number that was entered is : %d”, *pnum);
return 0;
}
OUTPUT:
Enter the number : 10
The number that was entered is : 10
 POINTER EXPRESSIONS AND POINTER ARITHMETIC
● Pointer variables can also be used in expressions. For ex,
int num1=2, num2= 3, sum=0, mul=0, div=1;
int *ptr1, *ptr2;
ptr1 = &num1, ptr2 = &num2;
sum = *ptr1 + *ptr2;
mul = sum * *ptr1;
*ptr2 +=1;
div = 9 + *ptr1/*ptr2 - 30;
● We can add integers to or subtract integers from pointers as well as to subtract one pointer from the other.
● We can compare pointers by using relational operators in the expressions. For example p1 > p2 , p1==p2 and p1!=p2
are all valid in C.

When using pointers, unary increment (++) and decrement (--) operators have greater precedence than the dereference
operator (*). Therefore, the expression
*ptr++ is equivalent to *(ptr++). So the expression will increase the value of ptr so that it now points to the next element.
In order to increment the value of the variable whose address is stored in ptr, write (*ptr)++
Program to test whether a number is positive, negative, or equal to zero.
#include<stdio.h>
int main()
{
int num, *pnum=&num;
printf(“\n enter any number”);
scanf(“%d”, pnum);
if(*pnum>0)
printf(“\n the number is positive”);
else
{
if(*pnum<0)
printf(“\n the number is negative”);
else
printf(“\n the number is equal to zero”);
}
return 0;
}
 PASSING ARGUMENTS TO FUNCTION USING POINTERS
The calling function sends the addresses of the variables and the called function must declare those
incoming arguments as pointers. In order to modify the variables sent by the caller, the called function
must dereference the pointers that were passed to it. Thus, passing pointers to a function avoid the
overhead of copying data from one function to another.
#include<stdio.h>
Void sum(int *a, int *b, int * t);
int main()
{
int num1, num2, total;
printf(“\n Enter two numbers : “);
scanf(“%d %d”, &num1, &num2);
sum(&num1, &num2, &total);
printf(“\n Total = %d”, total);
return 0;
}
void sum ( int *a, int *b, int *t)
{
*t = *a + *b;
}
Demonstrate how to read data from the keyboard, write it to a file called BMSCE, again read //the same
data from the BMSCE file, and display it on the screen/console.

#include<stdio.h>
int main()
{
FILE *fp;char c;
printf("Data read from the keyboard : Input\n\n");
/* Open the file INPUT */
fp = fopen("BMSCE.txt", "a");
/* Get a character from keyboard */
while((c=getchar()) != EOF)
/* Write a character to INPUT */
fputc(c,fp);
/* Close the file INPUT */
fclose(fp);
printf("\nData Output\n\n");
/* Reopen the file INPUT */
fp = fopen("BMSCE.txt","r");
/* Read a character from INPUT*/
while((c=fgetc(fp)) != EOF)
/* Display a character on screen */
printf("%c",c);
 INTRODUCTION TO FILES
● A file is a collection of data stored on a secondary storage device like hard disk.
● A file is basically used because real life applications involve large amounts of data and in such situations the console
oriented I/O operations pose two major problems:
● First, it becomes cumbersome and time consuming to handle huge amount of data through terminals.
● Second, when doing I/O using terminal, the entire data is lost when either the program is
terminated or computer is turned off. Therefore, it becomes necessary to store data on a
permanent storage (the disks) and read whenever necessary, without destroying the data.

STREAMS IN C
● In C, the standard streams are termed as pre-connected input and output channels between a text terminal and the
program (when it begins execution). Therefore, stream is a logical interface to the devices that are connected to the
computer.
● Stream is widely used as a logical interface to a file where a file can refer to a disk file, the computer screen, keyboard,
etc. Although files may differ in the form and capabilities, all streams are the same.
● The three standard streams in C languages are- standard input (stdin), standard output (stdout)
and standard error (stderr).
 STREAMS IN C contd.
● Standard input (stdin): Standard input is the stream from which the program receives its
data. The program requests transfer of data using the read operation. However, not all
programs require input. Generally, unless redirected, input for a program is expected from KEYBOARD

the keyboard. stdin

● Standard output (stdout): Standard output is the stream where a program writes its PROGRAM

output data. The program requests data transfer using the write operation. However, stderr

not all programs generate output. SCREEN

● Standard error (stderr): Standard error is basically an output stream used by stdout

programs to report error messages or diagnostics. It is a stream independent of

standard output and can be redirected
separately. No doubt, the standard output and standard error can also
be directed to the same destination.
● A stream is linked to a file using an open operation and disassociated
from a file using a close operation.
 BUFFER ASSOCIATED WITH FILE
● STREAM
When a stream linked to a disk file is created, a buffer is automatically created and associated with the
stream. A buffer is nothing but a block of memory that is used for temporary storage of data that has to
be read from or written to a file.
● Buffers are needed because disk drives are block oriented devices as they can operate efficiently
when data has to be read/ written in blocks of certain size. The size of ideal buffer size is hardware
dependant.
● The buffer acts as an interface between the stream (which is character-oriented) and the disk hardware
(which is block oriented). When the program has to write data to the stream, it is saved in the buffer till it
is full. Then the entire contents of the buffer are written to the disk as a block.

Data from the buffer is written to the disk file

Program writes data to buffer

PROGRAM BUFFER DISK

Similarly, when reading data from a disk file, the data is read as a block from the file and written into the
buffer. The program reads data from the buffer. The creation and operation of the buffer is automatically
handled by the operating system. However, C provides some functions for buffer manipulation. The data
resides in the buffer until the buffer is flushed or written to a file.
 TYPES OF FILES
● In C, the types of files used can be broadly classified into two categories- text files and
binary files.
ASCII Text files
● A text file is a stream of characters that can be sequentially processed by a computer in forward direction. For this
reason a text file is usually opened for only one kind of operation (reading, writing, or appending) at any given time.
● Because text files only process characters, they can only read or write data one character at a
time.
● In a text file, each line contains zero or more characters and ends with one or more characters that specify the end
of line. Each line in a text file can have maximum of 255 characters.
● A line in a text file is not a c string, so it is not terminated by a null character. When data is
written to a text file, each newline character is converted to a carriage return/line feed character.
Similarly, when data is read from a text file, each carriage return/ line feed character is
converted in to newline character.
● Another important thing is that when a text file is used, there are actually two representations of data- internal or
external. For ex, an int value will be represented as 2 or 4 bytes of memory internally but externally the int value will
be represented as a string of characters representing its decimal or hexadecimal value. To convert internal
representation into external, we can use printf and fprintf functions. Similarly, to convert an external representation
into internal scanf and fscanf can be used.
 BINARY FILES
● A binary file is a file which may contain any type of data, encoded in binary form for computer storage and processing
purposes. Like a text file, a binary file is a collection of bytes. Note that in C a byte and a character are equivalent.
Therefore, a binary file is also referred to as a character stream with following two essential differences.
● A binary file does not require any special processing of the data and each byte of data is
transferred to or from the disk unprocessed.
● C places no constructs on the file, and it may be read from, or written to, in any manner the
programmer wants.
● Binary files store data in the internal representation format. Therefore, an int value will be stored
I binary form as 2 or byte value. The same format is used to store data in memory as well as in file. Like text file,
binary file also ends with an EOF marker.
● Binary files can be either processed sequentially or randomly.
● In a text file, an integer value 123 will be stored as a sequence of three characters- 1, 2 and 3. So each character will
take 1 byte and therefore, to store the integer value 123 we need 3 bytes. However, in a binary file, the int value 123
will be stored in 2 bytes in the binary form.

This clearly indicates that binary files takes less space to store the same piece of data and
eliminates conversion between internal and external representations and are thus more efficient
than the text files.
 USING FILES IN C
● To use files in C, we must follow the steps given below.
● Declare a file pointer variable
● Open the file
● Process the file
● Close the file
Declaring a file pointer variable
● There can be a number of files on the disk. In order to access a particular file, you must specify the name of the
file that has to be used. This is accomplished by using a file pointer variable that points to a structure FILE
(defined in stdio.h). The file pointer will then be used in all subsequent operations in the file. The syntax for
declaring a file pointer is
● FILE *file_pointer_name;
For example, if we write
● FILE *fp;
Then, fp is declared as a file pointer.
● An error will be generated if you use the filename to access a file rather than the file pointer
Opening a File
● A file must be first opened before data can be read from it or written to it. In order to open a file and associate it with a
stream, the fopen() function is used. The prototype of fopen() can be given as:
● FILE *fopen(const char *file_name, const char *mode);
● Using the above prototype, the file whose pathname is the string pointed to by file_name is opened in the mode
specified using the mode. If successful, fopen() returns a pointer-to- structure and if it fails, it returns NULL.

MODE DESCRIPTION
r Open a text file for reading. If the stream (file) does not exist then an error will be reported.
Open a text file for writing. If the stream does not exist then it is created otherwise if the file already exists, then its
w
contents would be deleted
a Append to a text file. if the file does not exist, it is created.
rb Open a binary file for reading. B indicates binary. By default this will be a sequential file in Media 4 format
wb Open a binary file for writing
ab Append to a binary file
Open a text file for both reading and writing. The stream will be positioned at the beginning of the file. When you
r+ specify "r+", you indicate that you want to read the file before you write to it. Thus the file must already exist.

Open a text file for both reading and writing. The stream will be created if it does not exist, and will be truncated
w+
if it exist.
a+ Open a text file for both reading and writing. The stream will be positioned at the end of the file content.
r+b/ rb+ Open a binary file for read/write
w+b/wb+ Create a binary file for read/write
a+b/ab+ Append a binary file for read/write
 OPENINING A FILE contd.
● The fopen() can fail to open the specified file
FILE *fp;
under certain conditions that are listed below:
fp = fopen("Student.DAT", "r");
● Opening a file that is not ready for usage
if(fp==NULL)
● Opening a file that is specified to be on a
{
non-existent directory/drive printf("\n The file could not be opened");
● Opening a non-existent file for reading exit(1);
● Opening a file to which access is not permitted }
OR
char filename[30];
FILE *fp;
gets(filename);
fp = fopen(filename, "r+");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
 CLOSING A FILE USING FCLOSE()
To close an open file, the fclose() function is used which disconnects a file pointer

After the fclose() has disconnected the file pointer from the file, the pointer can be used to
access a different file or the same file but in a different mode.
● The fclose() function not only closes the file but also flushed all the buffers that are maintained
for that file
● If you do not close a file after using it, the system closes it automatically when the program exits. However,
since there is a limit on the number of files which can be open simultaneously; the programmer must close a
file when it has been used. The prototype of the fclose() function can be given as,
● int fclose(FILE *fp);
● Here, fp is a file pointer which points to the file that has to be closed. The function returns an integer
value which indicates whether the fclose() was successful or not. A zero is returned if the function was
successful; and a non-zero value is returned if an error occurred.
 READ DATA FROM FILES
● C provides the following set of functions to read data from a file.
● fscanf() fgets() fgetc() fread()
fscanf()
The fscanf() is used to read formatted data from the stream. The syntax of the fscanf() can be given as,
● int fscanf(FILE *stream, const char *format,…);
● The fscanf() is used to read data from the stream and store them according to the parameter format into the locations
pointed by the additional arguments.
#include<stdio.h>
main()
{
FILE *fp;
char name[80];
int roll_no;
fp = fopen("Student.DAT", "r");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1); }
printf("\n Enter the name and roll number of the student : ");
fscanf(stdin, "%s %d", name, &roll_no); /* read from keyboard */
printf(“\n NAME : %s \t ROLL NUMBER = %d", name, roll_no);
// READ FROM FILE- Student.DAT
fscanf(fp, "%s %d", name, &roll_no);
printf(“\n NAME : %s \t ROLL NUMBER = %d", name, roll_no);
fclose(fp); }
 fgets()

● fgets() stands for file get string. The fgets() function is used to get a string from a stream. The syntax of fgets() can be
given as:
char *fgets(char *str, int size, FILE *stream);
● The fgets() function reads at most one less than the number of characters specified by size (gets size - 1 characters)
from the given stream and stores them in the string str. The fgets() terminates as soon as it encounters either a
newline character or end-of-file or any other error.
However, if a newline character is encountered it is retained. When all the characters are read without any error, a '\0'
character is appended to end the string.

FILE *fp;
char str[80];
fp = fopen("Student.DAT", "r");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
while (fgets(str, 80, fp) != NULL)
printf("\n %s", str);
printf("\n\n File Read. Now closing the file");
fclose(fp);
fgetc()
● The fgetc() function returns the next character from stream, or EOF if the end of file is reached
or if there is an error. The syntax of fgetc() can be given as
● int fgetc( FILE *stream );
● fgetc returns the character read as an int or return EOF to indicate an error or end of file.
● fgetc() reads a single character from the current position of a file (file associated with stream). After
reading the character, the function increments the associated file pointer (if defined) to point to the next
character. However, if the stream has already reached the end of file, the end- of-file indicator for the
stream is set.
FILE *fp;
char str[80];
int i, ch;
fp = fopen("Program.C", "r");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
// Read 79 characters and store them in str
ch = fgetc(fp);
for( i=0; (i < 79 ) && ( feof( fp ) == 0 ); i++ )
{
str[i] = (char)ch;
ch = fgetc( stream );
}
str[i] = '\0';
printf( "\n %s", str);
 fread()
● The fread() function is used to read data from a file. Its syntax can be given as
● int fread( void *str, size_t size, size_t num, FILE *stream );
● The function fread() reads num number of objects (where each object is size bytes) and places

them into the array pointed to by str. The data is read from the given input stream.
● Upon successful completion, fread() returns the number of bytes successfully read. The number of objects will be
less than num if a read error or end-of-file is encountered. If size or num is 0, fread() will return 0 and the contents of
str and the state of the stream remain unchanged. In case of error, the error indicator for the stream will be set.
● The fread() function advances the file position indicator for the stream by the number of bytes
read.
FILE *fp;
char str[11];
fp = fopen("Letter.TXT", "r+"); if(fp==NULL)
{
printf("\n The file could not be opened"); exit(1);
}
fread(str, 1, 10, fp);
str[10]= '\0';
printf("\n First 9 characters of the file are : %s", str);
fclose(fp);
 WRITING DATA TO FILES
● C provides the following set of functions to read data from a file.
● fprintf() fputs() fputc() fwrite()
fprintf()
● The fpritnt() is used to write formatted output to stream. Its syntax can be given as,
● int fprintf ( FILE * stream, const char * format, ... );
● The function writes to the specified stream, data that is formatted as specified by the format argument. After the
format parameter, the function can have as many additional arguments as specified in format.
● The parameter format in the fprintf() is nothing but a C string that contains the text that has to be written on to the
stream.
FILE *fp; int i;
char name[20];
float salary;
fp = fopen("Details.TXT", "w");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
for(i=0;i<10;i++)
{
puts("\n Enter your name : ");
gets(name);
fflush(stdin);
puts("\n Enter your salary : ");
fputs()
● The fputs() is used to write a line into a file. The syntax of fputs() can be given as
● int fputs( const char *str, FILE *stream );
● The fputs() writes the string pointed to by str to the stream pointed to by stream. On successful
completion, fputs() returns 0. In case of any error, fputs() returns EOF.

● #include<stdio.h
> main()
{
FILE *fp;
char feedback[100];
fp = fopen("Comments.TXT",
"w"); if(fp==NULL)
{
printf("\n The file could not be
opened"); exit(1);
}
printf("\n Kindly give the feedback on this book :
"); gets(feedback);
fflush(stdin);
fputs(feedback,
fp);
fclose(fp);
}
 fputc()
● The fputc() is used to write a character to the stream.
● int fputc(int c, FILE *stream);
● The fputc() function will write the byte specified by c (converted to an unsigned char) to the
output stream pointed to by stream. Upon successful completion, fputc() will return the value it has written. Otherwise, in
case of error, the function will return EOF and the error indicator for the stream will be set.
● #include<stdio.h>
main()
{
FILE *fp;
char feedback[100];
int i;
fp = fopen("Comments.TXT", "w"); if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
printf("\n Kindly give the feedback on this book : ");
gets(feedback);
for(i=0i<feedback[i];i++)
fputc(feedback[i], fp);
fclose(fp);
}
fwrite()
● The fwrite() is used to write data to a file. The syntax of fwrite can be given as,
● int fwrite(const void *str, size_t size, size_t count, FILE *stream);
● The fwrite() function will write, from the array pointed to by str, up to count objects of size specified by size, to the
stream pointed to by stream.
● The file-position indicator for the stream (if defined) will be advanced by the number of bytes successfully written. In case
of error, the error indicator for the stream will be set.
main(void)
{
FILE *fp;
size_t count;
char str[] = "GOOD MORNING ";
fp = fopen("Welcome.txt", "wb");
if(fp==NULL)
{
printf("\n The file could not be opened");
exit(1);
}
count = fwrite(str, 1, strlen(str), fp);
printf("\n %d bytes were written to the files”, count);
fclose(fp);
}
fwrite() can be used to write characters, integers, structures, etc to a file. However, fwrite() can be used only with files that are opened in
binary mode.