Unit 3

Arrays and Pointers

 Pointers

• As you know, every variable is a memory

location and every memory location has its
address defined which can be accessed using
ampersand & operator, which denotes an
address in memory.
• A pointer is a variable whose value is the
address of another variable, i.e., direct address
of the memory location. Like any variable or
constant, you must declare a pointer before you
can use it to store any variable address.
 Print the address of the variables defined:
#include<stdio.h>
int main () {
int var1;
char var2[10];
printf("Address of var1 variable: %x\n", &var1 );
printf("Address of var2 variable: %x\n", &var2 );
return 0;
}
Output
Address of var1 variable: bff5a400
Address of var2 variable: bff5a3f6
 Declaration of a Pointer
type *var-name;
• Here, type is the pointer's base type; it must
be a valid C data type and var-name is the
name of the pointer variable. The asterisk *
you used to declare a pointer is the same
asterisk that you use for multiplication.
 Some more declaration format of pointers
• int *ip; /* pointer to an integer */
• double *dp; /* pointer to a double */
• float *fp; /* pointer to a float */
• char *ch /* pointer to a character */
• ** pointer to a pointer.
 How to use Pointers
• There are few important operations, which we
will do with the help of pointers very
frequently.
1. We define a pointer variable
2. Assign the address of a variable to a pointer
3. Finally access the value at the address
available in the pointer variable.
This is done by using unary operator * that
returns the value of the variable located at
the address specified by its operand.
#include<stdio.h>
int main () {
int var = 20; /* actual variable declaration */
int *ip; /* pointer variable declaration */
ip = &var; /* store address of var in pointer variable*/
printf("Address of var variable: %x\n", &var );
/* address stored in pointer variable */
printf("Address stored in ip variable: %x\n", ip );
/* access the value using the pointer */
printf("Value of *ip variable: %d\n", *ip );
return 0;
}
 Output
• Address of var variable: bffd8b3c
//hexadecimal.a-f, 0-9= ffffffffffffffff
• Address stored in ip variable: bffd8b3c
• Value of *ip variable: 20 = Var
 NULL Pointers in C
• A pointer that is assigned NULL is called a null pointer.
• The NULL pointer is a constant with a value of zero
defined in several standard libraries.
#include<stdio.h>
int main () {
int *ptr = NULL;
printf("The value of ptr is : %x\n", ptr );
return 0;
}
Output
The value of ptr is 0.
 Advantages of Pointers
1) Pointer reduces the code and improves the
performance, it is used to retrieving strings,
trees, etc. and used with arrays, structures,
and functions.
2) We can return multiple values from a
function using the pointer.
3) It makes you able to access any memory
location in the computer's memory.
 Address Of (&) Operator

The address of operator '&' returns the address of a

variable. But, we need to use %u to display the address
of a variable.
#include<stdio.h>  
int main(){  
int number=50;   
printf("value of number is %d, address of
number is %u",number,&number);    
return 0;  
}
Output
value of number is 50, address of number is fff4.   
 Pointer to Array
• int arr[10];  
• int *p[10]=&arr; // Variable p of type pointer 
is pointing to the address of an integer array
 arr. 
 Pointer to a Function
• void show (int);  
• void(*p)(int) = &display; // Pointer p is 
pointing to the address of a function  
 Reading complex pointers

• (): This operator is a bracket operator used to

declare and define the function.
• []: This operator is an array subscript operator
• * : This operator is a pointer operator.
• Identifier: It is the name of the pointer. The
priority will always be assigned to this.
• Data type: Data type is the type of the variable
to which the pointer is intended to point. It
also includes the modifier like signed int, long,
etc)
 How to read the pointer:
• int (*p)[10].
• To read the pointer, we must see that () and [] have the
equal precedence. Therefore, their associativity must be
considered here. The associativity is left to right, so the
priority goes to ().
• Inside the bracket (), pointer operator * and pointer name
(identifier) p have the same precedence. Therefore, their
associativity must be considered here which is right to left,
so the priority goes to p, and the second priority goes to *.
• Assign the 3rd priority to [] since the data type has the last
precedence.
• eg. int (*p)(int (*)[2], int (*)void))  
• int (*p)(int (*)[2], int (*)void))  
• This pointer will be read as p is a pointer to
such function which accepts the first
parameter as the pointer to a one-
dimensional array of integers of size two and
the second parameter as the pointer to a
function which parameter is void and return
type is the integer.
 Double Pointer (Pointer to Pointer)

•  we can also define a pointer to store the

address of another pointer. Such pointer is
known as a double pointer (pointer to pointer).
The first pointer is used to store the address of
a variable whereas the second pointer is used
to store the address of the first pointer.
• The syntax of declaring a double pointer is
given below.
• int **p; // pointer to a pointer which is pointin
g to an integer.   
#include<stdio.h>  
void main ()  
{  
    int a = 10;  
    int *p;  
    int **pp;   
    p = &a; // pointer p is pointing to the address of a  
    pp = &p; // pointer pp is a double pointer pointing to the address of pointer 
p  
    printf("address of a: %x\n",p); // Address of a will be printed   
    printf("address of p: %x\n",pp); // Address of p will be printed  
    printf("value stored at p: %d\n",*p); // value stored at the address 
contained by p i.e. 10 will be printed  
    printf("value stored at pp: %d\n",**pp); // value stored at the
 address contained by the pointer stored at pp  
}  
pp= 10 (abc)  p= 10(xyz);(abc) a(xyz) =10
• Output
address of a: d26a8734
address of p: d26a8738
value stored at p: 10
value stored at pp: 10
 Relationship between arrays and pointers
Arrays and pointers are closely related in C. In fact an array
declared as
int A[10]; 0,1,2,3,4,5,6,7,8,9 A[4];
can be accessed using its pointer representation.
The name of the array A is a constant pointer to the first
element of the array. So A can be considered a const int*.
Since A is a constant pointer, A = NULL would be an illegal
statement. Arrays and pointers are synonymous in terms of
how they use to access memory. But, the important
difference between them is that, a pointer variable can take
different addresses as value whereas, in case of array it is
fixed.
 Argument passing using pointers
#include <stdio.h>
#include <time.h>
void getSeconds(unsigned long *par);
int main () {
unsigned long sec;
getSeconds( &sec ); /* print the actual value */
printf("Number of seconds: %ld\n", sec );
return 0;
}
 Array of Pointers
Simple program of 3 variables
#include <stdio.h>
const int MAX = 3;
int main () {
int var[] = {10, 100, 200};
int i;
for (i = 0; i < MAX; i++) {
printf("Value of var[%d] = %d\n", i, var[i] );
} return 0;
}
Var[0] =10, Var[1] = 100, Var[2]= 200,
 Output
Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200
 Same Program using Pointers
#include <stdio.h>
const int MAX = 3;
int main () {
int var[] = {10, 100, 200};
int i, *ptr[MAX];
for ( i = 0; i < MAX; i++) {
ptr[i] = &var[i]; /* assign the address of integer. */ }
for ( i = 0; i < MAX; i++) {
printf("Value of var[%d] = %d\n", i, *ptr[i] );
} return 0;
}
 Find the area and the perimeter of a circle using call by reference function.

#include<stdio.h>
Void areaperi( int, float*, float*);
Void main() {
Int radius;
Float area, perimeter;
Printf(“Enter radius of a circle”);
Scanf(“%d”,&radius);
Areaperi(radius, &area, &perimeter);
Printf(“Area= %f”, area);
Printf(“\nPerimeter = %f”, perimeter);}
Void areaperi(int r, float *a, float *p)
{ *a= 3.14*r*r;
*p = 2 * 3.14 *r}
 Pointers to functions
• In C, like normal data pointers (int *, char *, etc), we can have pointers to functions. 
#include <stdio.h>
void fun(int a)
{
printf("Value of a is %d\n", a);
}
int main()
{
// fun_ptr is a pointer to function fun()
void (*fun_ptr)(int) = &fun;
/* The above line is equivalent of following two
void (*fun_ptr)(int);
fun_ptr = &fun;
*/
// Invoking fun() using fun_ptr
(*fun_ptr)(10);
return 0;
}
• Output:
• Value of a is 10
 How to declare a pointer to a function?
1) Unlike normal pointers, a function pointer points to code, not
data. Typically a function pointer stores the start of executable
code.
• 2) Unlike normal pointers, we do not allocate de-allocate
memory using function pointers.
•  
3) A function’s name can also be used to get functions’ address.
{ 
    void (*fun_ptr)(int) = fun;  // & removed
    fun_ptr(10);  // * removed
    return 0;
}
4) Like normal pointers, we can have an array of function pointers.
5) Function pointer can be used in place of switch case. For example, in below program, user is asked for
a choice between 0 and 2 to do different tasks.
#include <stdio.h>
void add(int a, int b)
{ printf("Addition is %d\n", a+b);
}
void subtract(int a, int b)
{ printf("Subtraction is %d\n", a-b);
}
void multiply(int a, int b)
{ printf("Multiplication is %d\n", a*b);
}
int main()
{ // fun_ptr_arr is an array of function pointers
void (*fun_ptr_arr[])(int, int) = {add, subtract, multiply};
unsigned int ch, a = 15, b = 10;
printf("Enter Choice: 0 for add, 1 for subtract and 2 ""for multiply\n");
scanf("%d", &ch);
if (ch > 2) return 0;
(*fun_ptr_arr[ch])(a, b);
return 0;
}
Output:- Enter Choice: 0 for add, 1 for subtract and 2 for multiply 2 Multiplication is 150
6) Like normal data pointers, a function pointer can be passed as an argument
and can also be returned from a function.
#include <stdio.h>
void fun1() { printf("Fun1\n"); }
void fun2() { printf("Fun2\n"); }
// A function that receives a simple function as parameter and calls the function
void wrapper(void (*fun)())
{
fun();
}

int main()
{
wrapper(fun1);
wrapper(fun2);
return 0;
}
 Strings and Pointer
•  a string is a sequence of characters which we save in an
array. And in C programming language the \0 null character
marks the end of a string.
• Creating a string
• In the following example we are creating a
string str using char character array of size 6.
• char str[6] = "Hello";
• The above string can be represented in memory as follows.
 Creating a pointer for the string
• The variable name of the string str holds the address of the first element of the
array i.e., it points at the starting memory address.
• So, we can create a character pointer ptr and store the address of the
string str variable in it. This way, ptr will point at the string str.
• In the following code we are assigning the address of the string str to the
pointer ptr.
• char *ptr = str;
• We can represent the character pointer variable ptr as follows.
• The pointer variable ptr is allocated memory address 8000 and it holds the address
of the string variable str i.e., 1000.
 Accessing string via pointer
• To access and print the elements of the string we can use a loop and check for the \
0 null character.
• In the following example we are using while loop to print the characters of the string
variable str.
#include <stdio.h>
int main(void) {
// string variable
char str[6] = "Hello";
// pointer variable
char *ptr = str;
// print the string
while(*ptr != '\0') {
printf("%c", *ptr);
// move the ptr pointer to the next memory location
ptr++;
}
return 0;
}
 Using Pointer to Store String
• We can achieve the same result by creating a character
pointer that points at a string value stored at some memory
location.

• In the above image the string "Hello" is saved in the memory

location 5000 to 5005.
• The pointer variable strPtr is at memory location 8000 and is
pointing at the string address 5000.
• The temporary variable is also assigned the address of the
string so, it too holds the value 5000 and points at the
starting memory location of the string "Hello".
 Array of strings
• We can create a two dimensional array and save
multiple strings in it.
char city[4][12] = { "Chennai", "Kolkata", "Mumbai",
"New Delhi" };
 Structure
• Structure stores the different types of
elements i.e heterogeneous elements.
The struct keyword is used to define structure.
Syntax
struct structure_name
{
data_type member1;
  data_type memeberN;
};
 Simple Program Using Structure
#include <stdio.h>
#include <string.h>
struct student {
int rollno;
char name[60];
}s1;  //declaring s1 variable for structure
void main( ) {
//store first employee information
s1.rollno=1;
strcpy(s1.name, “Aman”);//copying string into char array
//printing first employee information
printf( "Rollno : %d\n", s1.rollno);
printf( "Name : %s\n", s1.name);
}
 Output

Rollno : 1
Name : Aman
 Additional Features of Structure
• The values of a structure variable can be assigned
to another structure variable of the same type
using the assignment operator.
• One structure can be nested within another
structure. Using this facility, complex data types
can be created.
• Like an ordinary variable, a structure variable can
also be passed to a function.
• The way we can have a pointer pointing to an int,
or a pointer pointing to a char, similarly we can
have a pointer pointing to a struct.
 Uses of Structure
• Changing the size of the cursor
• Changing the content of the screen
• Placing the cursor at an appropriate position on
screen.
• Receiving a key from keyboard.
• Displaying the directory of a disk
• Sending the output to printer
• Interacting with the mouse.
• Hiding the file from the directory.
 Union
• Union also stores the different types of elements i.e
heterogeneous elements. The union keyword is used
to define structure. Union takes the memory of largest
member only so occupies less memory than
structures.
Syntax
union union_name {
data_type member1;

  data_type memeberN;
}Variable1, Variable2..;
 Simple Program Using Union
#include <stdio.h>
#include <string.h>
union student {
int rollno;
char name[60];
}s1; 
//declaring s1 variable for union
void main( ) {
//store first employee information
s1.rollno=1;
strcpy(s1.name, “Aman”);//copying string into char array
//printing first employee information
printf( "Rollno : %d\n", s1.rollno);
printf( "Name : %s\n", s1.name);
}
 Output
Output
Rollno : 3546656
Name : Aman
Rollno takes garbage value because name has
large memory size. So only name will have
actual value.
 Difference between Structure and Union
• Structure and union both are user defined data types which
contains variables of different data types. Both of them have
same syntax for definition, declaration of variables and for
accessing members. Still there are many difference between
structure and union. In this tutorial we will take a look on
those differences.
• In structure each member get separate space in memory.
Take below example.
• struct student { int rollno; char gender; float marks; }s1;
• The total memory required to store a structure variable is
equal to the sum of size of all the members. In above case 7
bytes (2+1+4) will be required to store structure variable s1.
• In union, the total memory space allocated is equal to the member with
largest size. All other members share the same memory space. This is the
biggest difference between structure and union.
• union student { int rollno; char gender; float marks; }s1;
• In above example variable marks is of float type and have largest size (4
bytes). So the total memory required to store union variable s1 is 4 bytes.
• We can access any member in any sequence.
• s1.rollno = 20; s1.marks = 90.0; printf("%d",s1.rollno);
• The above code will work fine but will show erroneous output in the case of
union. We can access only that variable whose value is recently stored.
• s1.rollno = 20; s1.marks = 90.0; printf("%d",s1.rollno);
• The above code will show erroneous output. The value of rollno is lost as
most recently we have stored value in marks. This is because all the members
share same memory space.
• All the members can be initialized while declaring the variable of structure.
Only first member can be initialized while declaring the variable of union. In
above example we can initialize only variable rollno at the time of declaration
of variable.
 BASIS OF COMPARISON STRUCTURE UNION
Basic The separate memory location is All members of the 'union' share
allotted to each member of the the same memory location.
'structure'.

Declaration struct struct_name{ union u_name{

type element1; type element1;
type element2; type element2;
. .
. .
} variable1, variable2, ...; } variable1, variable2, ...;
keyword 'struct' 'union'
Size Size of Structure= sum of size of all Size of Union=size of the largest
the data members. members.

Store Value Stores distinct values for all the Stores same value for all the
members. members.

At a Time A 'structure' stores multiple values, A 'union' stores a single value at

of the different members, of the a time for all members.
'structure'.

Way of Viewing Provide single way to view each Provide multiple way to to view
memory location. same memory location.

Anonymous feature No Anonymous feature. Anonymous union can be

declared.
 String
• Strings are actually one-dimensional array of characters
terminated by a null character '\0'. Thus a null-terminated
string contains the characters that comprise the string
followed by a null.
• The following declaration and initialization create a string
consisting of the word "Hello". To hold the null character at
the end of the array, the size of the character array
containing the string is one more than the number of
characters in the word "Hello."
• char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; If you follow the
rule of array initialization then you can write the above
statement as follows −
• char greeting[] = "Hello";
• Actually, you do not place the null character at the end of a
string constant. The C compiler automatically places the '\0'
at the end of the string when it initializes the array.
 A simple program
#include <stdio.h>
int main () {
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
printf("Greeting message: %s\n", greeting );
return 0;
}
OUTPUT
Greeting message: Hello
 String Functions and their purpose
S No. Function Purpose

1 strcpy(s1, s2); Copies string s2 into string s1.

2 strcat(s1, s2); goodmorning Concatenates string s2 onto the end

of string s1.

3 strlen(s1); goodmorning = 11 Returns the length of string s1.

4 strcmp(s1, s2); Returns 0 if s1 and s2 are the same;

less than 0 if s1<s2; greater than 0 if
s1>s2.

5 strchr(s1, ch); adchachu=s1 Returns a pointer to the first

occurrence of character ch in string
s1.

6 strstr(s1, s2);s1= welcome home. Returns a pointer to the first

S2= home. occurrence of string s2 in string s1.
 An example using these functions
#include <stdio.h>
#include <string.h>
int main () {
char str1[12] = "Hello"; // HelloWorld
char str2[12] = "World";
char str3[12]; int len ;
/* copy str1 into str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 ); // Hello
/* concatenates str1 and str2 */
strcat( str1, str2); // == str1.
printf("strcat( str1, str2): %s\n", str1 ); // HelloWorld
/* total lenghth of str1 after concatenation */
len = strlen(str1);
printf("strlen(str1) : %d\n", len ); \\10
return 0;
}
 OUTPUT
strcpy( str3, str1) : Hello
strcat( str1, str2): HelloWorld
strlen(str1) : 10
 String library functions
• strcat ( )Concatenates str2 at the end of str1
• strncat ( )Appends a portion of string to another Hello Wolrd
• strcpy ( )Copies str2 into str1
• strncpy ( )Copies given number of characters of one string to
another
• strlen ( )Gives the length of str1
• strcmp ( )Returns 0 if str1 is same as str2. Returns <0 if strl <
str2. Returns >0 if str1 > str2
• strcmpi ( )Same as strcmp() function. But, this function negotiates
case.  “A” and “a” are treated as same.
• strchr ( )Returns pointer to first occurrence of char in str1
• strrchr ( )last occurrence of given character in a string is found
• strstr ( )Returns pointer to first occurrence of str2 in str1
• strrstr ( )Returns pointer to last occurrence of str2 in str1
• strdup ( )Duplicates the string
• strlwr ( )Converts string to lowercase
• strupr ( )Converts string to uppercase
• strrev ( )Reverses the given string.- gnirts
• strset ( )Sets all character in a string to given
character
• strnset ( )It sets the portion of characters in a
string to given character
• strtok ( )Tokenizing given string using delimiter
Basic File Operations in C Programming

• There are 4 basic operations that can be

performed on any files in C programming
language. They are,
• Opening/Creating a file
• Closing a file
• Reading a file
• Writing in a file
1. fopen() – To open a file.
• Declaration: FILE *fopen (const char *filename, const
char *mode)
• fopen() function is used to open a file to perform
operations such as reading, writing etc. In a C program,
we declare a file pointer and use fopen() as below.
fopen() function creates a new file if the mentioned file
name does not exist.
• FILE *fp;
fp=fopen (“filename”, ”‘mode”);
• Where,
fp – file pointer to the data type “FILE”.
filename – the actual file name with full path of the file.
2. fclose() – To close a file.
• Declaration: int fclose(FILE *fp);
• fclose() function closes the file that is being
pointed by file pointer fp. In a C program, we
close a file as below.
fclose (fp);
3. fgets() – To read a file.
• Declaration: char *fgets(char *string, int n,
FILE *fp)
• fgets function is used to read a file line by
line. In a C program, we use fgets function as
below.
fgets (buffer, size, fp);
• where,
buffer – buffer to  put the data in.
size – size of the buffer
fp – file pointer
4. fprintf() – To write into a file.
Declaration:
int fprintf(FILE *fp, const char *format,
…);fprintf() function writes string into a file
pointed by fp. In a C program, we write string
into a file as below.
fprintf (fp, “some data”); or
fprintf (fp, “text %d”, variable_name);
 Simple program for writing in file
# include <stdio.h>     printf( "\n Enter some text from
# include <string.h> keyboard” \
               “ to write in the file test.c" ) ;
int main( )     // getting input from user
{     while ( strlen ( gets( data ) ) > 0 )
    FILE *fp ;     {
    char data[50];         // writing in the file
    // opening an existing file         fputs(data, fp) ;  
    printf( "Opening the file test.c in write         fputs("\n", fp) ;
mode" ) ;     }
    fp = fopen("test.c", "w") ;     // closing the file
    if ( fp == NULL )     printf("Closing the file test.c") ;
    {     fclose(fp) ;
        printf( "Could not open file test.c" ) ;     return 0;        
        return 1; }
    }
 OUTPUT
• Opening the file test.c in write mode
• Enter some text from keyboard to write in the
file test.c
Hai, How are you?
Closing the file test.c
 Simple program to read from a file
# include <stdio.h>
int main( )
{
         FILE *fp ;
         char data[50] ;
         printf( "Opening the file test.c in read mode" ) ;
         fp = fopen( "test.c", "r" ) ;
         if ( fp == NULL )
         {
                 printf( "Could not open file test.c" ) ;
                 return 1;
         }
         printf( "Reading the file test.c" ) ;
         while( fgets ( data, 50, fp ) != NULL )
         printf( "%s" , data ) ;
         printf("Closing the file test.c") ;
         fclose(fp) ;
         return 0;
}
 Output
• Opening the file test.c in read mode
• Reading the file test.c
• Hai, How are you?
• Closing the file test.c
 Modes and Description of file
1. r
Opens an existing text file for reading purpose.
2. w
Opens a text file for writing. If it does not exist, then a new file is created. Here your
program will start writing content from the beginning of the file.
3. a
Opens a text file for writing in appending mode. If it does not exist, then a new file is
created. Here your program will start appending content in the existing file content.
4. r+
Opens a text file for both reading and writing.
5. w+
Opens a text file for both reading and writing. It first truncates the file to zero length
if it exists, otherwise creates a file if it does not exist.
6. a+
Opens a text file for both reading and writing. It creates the file if it does not exist.
The reading will start from the beginning but writing can only be appended.
 Basic functions for file

• fopen()create a new file or open a existing file

• fclose()closes a file
• getc()reads a character from a file
• putc()writes a character to a file
• fscanf()reads a set of data from a file
• fprintf()writes a set of data to a file
• getw()reads a integer from a file
• putw()writes a integer to a file
• fseek()set the position to desire point
• ftell()gives current position in the file
• rewind()set the position to the begining point
 Difference between Sequential and Random Access
Files
• When we are talking about sequential or random access to
data files we refer to the way data is written or read from a
file on a computer system.
• Sequential Access to a data file means that the computer
system reads or writes information to the file sequentially,
starting from the beginning of the file and proceeding step
by step.
• On the other hand, Random Access to a file means that the
computer system can read or write information anywhere
in the data file. This type of operation is also called “Direct
Access” because the computer system knows where the
data is stored (using Indexing) and hence goes “directly”
and reads the data.
• Sequential access has advantages when you
access information in the same order all the
time. Also is faster than random access.
• On the other hand, random access file has the
advantage that you can search through it and
find the data you need more easily (using
indexing for example). Random Access Memory
(RAM) in computers works like that.
• As a quick example, modern computer hard
disks are using Random Access whereas Tape
Storage devices (used for offline backups) use
Sequential Access.
 File Positioning
• The file position of a stream describes where
in the file the stream is currently reading or
writing. I/O on the stream advances the file
position through the file.
• During I/O to an ordinary disk file, you can
change the file position whenever you wish,
so as to read or write any portion of the file.
Some other kinds of files may also permit this.
Files which support changing the file position
are sometimes referred to as random-
access files.
• The C library function int fseek(FILE *stream, long int offset, int
whence) sets the file position of the stream to the given offset.
• Declaration
int fseek(FILE *stream, long int offset, int whence)
Parameters
• stream − This is the pointer to a FILE object that identifies the
stream.
• offset − This is the number of bytes to offset from whence.
• whence − This is the position from where offset is added. It is
specified by one of the following constants −
1SEEK_SET- Beginning of file
2SEEK_CUR- Current position of the file pointer
3SEEK_END- End of file
Return Value- This function returns zero if successful, or else it
returns a non-zero value.
 Sample Example
#include <stdio.h>
int main () {
FILE *fp;
fp = fopen("file.txt","w+");
fputs("This is ITP Class", fp);
fseek( fp, 7, SEEK_SET );
fputs(" C Programming Language", fp);
fclose(fp);
return(0);
}
 Output
• This is C Programming Language