Unit 3-Two Marks

1. Define a pointer. How is a pointer variable declared and initialized in C?

A pointer is a variable that stores the address of another variable.
Declaration:
int *p;
Initialization:
int a = 10;
int *p = &a;

2. What is pointer arithmetic? Explain increment and decrement operations on

pointers.
Pointer arithmetic refers to performing arithmetic operations on pointer variables.
• Increment (p++): Moves the pointer to the next memory location of its data type.
• Decrement (p--): Moves the pointer to the previous memory location.
Example:
int a[3];
int *p = a;
p++; // points to next integer element

3. What is a NULL pointer? Why is it used in C programs?

A NULL pointer is a pointer that does not point to any valid memory location.
int *p = NULL;
Usage:
• To indicate that the pointer is not assigned
• To prevent accidental access to invalid memory
• Commonly used in conditional checks

4. What is a generic pointer? Give one situation where it is used.

A generic pointer is a pointer that can store the address of any data type.
void *gp;

Page 1 of 39
Situation where used:
Used in memory allocation functions like malloc().
int *p = (int *)malloc(sizeof(int));

5. Define a dangling pointer. How can dangling pointers be avoided?

A dangling pointer is a pointer that points to a memory location that has been freed or
deallocated.
Example:
int *p = (int *)malloc(sizeof(int));
free(p);
Avoidance methods:
• Assign the pointer to NULL after freeing memory
p = NULL;
• Avoid accessing memory after free()

Unit 3-6 marks

1. Explain the concept of pointers in C. Describe declaration, initialization, and pointer

expressions with suitable examples.
A pointer in C is a variable that stores the memory address of another variable. Pointers
provide indirect access to data and are widely used for efficient memory management and
function calls.
Declaration of a Pointer
A pointer is declared using the * operator.
int *p;
Initialization of a Pointer
A pointer is initialized with the address of a variable using the address-of operator &.
int a = 10;
int *p = &a;
Pointer Expressions
Pointer expressions involve dereferencing and address manipulation.
printf("%d", *p); // Dereferencing – prints value of a (10)

Page 2 of 39
printf("%p", p); // Prints address stored in pointer
Use: Pointers allow dynamic memory allocation, efficient array handling, and call-by-
reference.

2. Explain pointer arithmetic in detail. How does address arithmetic differ for different
data types?
Pointer arithmetic refers to performing arithmetic operations on pointer variables.
Operations Allowed
• Increment (p++)
• Decrement (p--)
• Addition and subtraction with integers
• Difference between two pointers (same type)
Example
int arr[3] = {10, 20, 30};
int *p = arr;
p++; // Points to next element
Data Type Dependency
Pointer arithmetic depends on the size of the data type:

Data Type Size Increment Effect

int 4 bytes Address increases by 4

float 4 bytes Address increases by 4

double 8 bytes Address increases by 8

char 1 byte Address increases by 1

Thus, pointer arithmetic is type-specific, not byte-specific.

3. Explain pointers as function arguments. Write a C program to swap two numbers

using pointers.
When pointers are passed as function arguments, the function receives the address of
variables, allowing modification of original values. This is called call by reference.

Page 3 of 39
Swap Program Using Pointers
#include <stdio.h>

void swap(int *x, int *y)

{
int temp;
temp = *x;
*x = *y;
*y = temp;
}

int main()
{
int a = 5, b = 10;
swap(&a, &b);
printf("a = %d, b = %d", a, b);
return 0;
}
Advantage: Changes made inside the function reflect in the calling function.

4. Explain the relationship between pointers and arrays. Illustrate with examples
including pointer to pointer.

Relationship between Pointers and Arrays

In C, arrays and pointers are closely related. The name of an array acts as a pointer to
the first element of the array. Hence, array elements can be accessed using either array
indexing or pointer arithmetic.
• The array name stores the base address of the array.
• A pointer can be assigned the address of the first array element.
• Expression a[i] is equivalent to *(a + i).
• Pointer arithmetic is used to move between array elements.

Page 4 of 39
Example: Pointer and Array
int a[3] = {10, 20, 30};
int *p = a;

printf("%d", a[1]); // Access using array index

printf("%d", *(p + 1)); // Access using pointer
Both statements access the second element of the array.

Pointer to Pointer
A pointer to pointer stores the address of another pointer.
int x = 10;
int *p = &x;
int **pp = &p;

printf("%d", **pp);
Here, pp points to pointer p, and **pp gives the value stored in x.

5. Explain dynamic memory allocation in C. Describe malloc(), calloc(), realloc(), and

free() with examples. Also explain command line arguments.

Dynamic Memory Allocation

Dynamic memory allocation allows memory to be allocated at runtime using functions from
stdlib.h.
Memory Allocation Functions
malloc()
Allocates a single block of memory (uninitialized).
int *p = (int *)malloc(5 * sizeof(int));
calloc()
Allocates multiple blocks and initializes them to zero.

Page 5 of 39
int *p = (int *)calloc(5, sizeof(int));
realloc()
Resizes previously allocated memory.
p = (int *)realloc(p, 10 * sizeof(int));
free()
Releases allocated memory.
free(p);

Command Line Arguments

Command line arguments allow passing data to the program at runtime.
int main(int argc, char *argv[])
• argc – argument count
• argv – argument vector
Example: Addition of two numbers
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{
int a = atoi(argv[1]);
int b = atoi(argv[2]);
printf("Sum = %d", a + b);
return 0;
}
Use: Useful for automation and runtime input.

Unit 4- 2 marks questions

1. Define a function in C. Write the general syntax of a function declaration.
A function in C is a block of code that performs a specific task and can be reused whenever
required.

Page 6 of 39
General syntax of function declaration:
return_type function_name(parameter_list);
Example:
int add(int a, int b);

2. Differentiate between function declaration and function definition.

Function Declaration Function Definition

Tells the compiler about the function’s name, return Contains the actual body (logic) of
type, and parameters the function

Ends with a semicolon Does not end with a semicolon

No executable code Executable code is present

Can be written multiple times Written only once

3. List the different categories of functions in C.

The different categories of functions in C are:
1. Function with no arguments and no return value
2. Function with arguments and no return value
3. Function with no arguments and return value
4. Function with arguments and return value

4. What is a function call? Explain its role in program execution.

A function call is a statement used to invoke or execute a function.
Role in program execution:
• Transfers control from the calling function to the called function
• Executes the function code
• Returns control back to the calling function after execution
Example:
sum = add(5, 3);

5. What is parameter passing? List different ways of passing parameters in C.

Page 7 of 39
Parameter passing is the method of transferring data from a calling function to a called
function.
Ways of passing parameters in C:
1. Call by Value
2. Call by Reference (using pointers)

6. Define scope of a variable. Mention types of variable scope in C.

The scope of a variable defines the region of the program where the variable is accessible.
Types of variable scope in C:
1. Local scope
2. Global scope
3. Block scope

7. What are storage classes? List any four storage classes in C.

Storage classes determine the scope, lifetime, and storage location of variables.
Four storage classes in C:
1. auto
2. register
3. static
4. extern

8. Define recursion. Mention one advantage and one disadvantage of recursion.

Recursion is a process in which a function calls itself to solve a problem.
Advantage:
• Simplifies code for problems like factorial and tree traversal
Disadvantage:
• Uses more memory due to multiple function calls

9. What is a string in C? How is it terminated?

A string in C is a sequence of characters stored in a character array.
It is terminated by a null character ('\0').

Page 8 of 39
Example:
char name[] = "C Programming";

10. Differentiate between string manipulation with library functions and without
library functions.

With Library Functions Without Library Functions

Uses functions from string.h Uses user-defined logic

Easier and faster to write Requires loops and conditions

Examples: strcpy(), strlen() Manual copying and counting

Less code More code

Unit 4-6 marks questions

1. Explain the structure of a C function with declaration, definition, and function call
using a suitable example.
A C function consists of three main parts: function declaration, function definition, and
function call.
(i) Function Declaration
It informs the compiler about the function’s name, return type, and parameters.
int add(int, int);
(ii) Function Definition
It contains the actual logic of the function.
int add(int a, int b)
{
return a + b;
}
(iii) Function Call
It is used to execute the function.
sum = add(10, 20);

Page 9 of 39
Complete Program
#include <stdio.h>

int add(int, int);

int main()
{
int sum;
sum = add(10, 20);
printf("Sum = %d", sum);
return 0;
}

int add(int a, int b)

{
return a + b;
}

2. Describe different categories of functions in C with appropriate examples.

Functions in C are categorized based on arguments and return values.
1. No arguments, no return value
void display()
{
printf("Hello");
}
2. Arguments, no return value
void sum(int a, int b)
{
printf("%d", a + b);
}

Page 10 of 39
3. No arguments, return value
int getValue()
{
return 10;
}
4. Arguments and return value
int add(int a, int b)
{
return a + b;
}

3. Explain parameter passing techniques in C. Illustrate call-by-value and call-by-

reference with programs.
Parameter Passing
It is the method of passing data from one function to another.
Call by Value
• Copy of value is passed
• Original value is not modified
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
Call by Reference
• Address is passed using pointers
• Original value is modified
void swap(int *a, int *b)
{
int temp = *a;
*a = *b;

Page 11 of 39
 *b = temp;
}

4. Analyze the scope of variables in C. Explain local, global, and block scope with
examples.

Scope of a Variable
The scope of a variable in C refers to the region of the program where the variable is
visible and can be accessed. Scope determines where a variable can be used and helps in
avoiding name conflicts.
1. Local Scope
A local variable is declared inside a function and is accessible only within that function.
void display()
{
int x = 10; // local variable
printf("%d", x);
}
• Exists only during function execution
• Cannot be accessed outside the function

2. Global Scope
A global variable is declared outside all functions and can be accessed by all functions in
the program.
int g = 20; // global variable

void show()
{
printf("%d", g);
}
• Accessible throughout the program
• Lifetime is the entire program execution

Page 12 of 39
3. Block Scope
A block scope variable is declared inside a block { }, such as if, for, or while.
if (1)
{
int y = 5; // block scope variable
printf("%d", y);
}
• Accessible only within the block
• Scope is limited to that block

5. Explain variable storage classes in C. Discuss auto, register, static, and extern with
examples.

Variable Storage Classes in C

In C, storage classes define the scope, lifetime, and storage location of variables. They
determine how long a variable exists in memory and where it can be accessed from.
The four commonly used storage classes are auto, register, static, and extern.
1. auto Storage Class
• Default storage class for local variables
• Stored in memory
• Scope is limited to the function
void func()
{
auto int x = 10;
printf("%d", x);
}

2. register Storage Class

• Requests storage in a CPU register
• Faster access than memory variables

Page 13 of 39
 • Address (&) cannot be used
void count()
{
register int i;
for(i = 0; i < 5; i++)
printf("%d ", i);
}

3. static Storage Class

• Retains its value between function calls
• Lifetime is the entire program execution
• Scope depends on declaration location
void demo()
{
static int count = 0;
count++;
printf("%d ", count);
}

4. extern Storage Class

• Used to declare a global variable defined in another file
• Does not allocate new memory
extern int g;

void show()
{
printf("%d", g);
}

Summary Table

Page 14 of 39
Storage Class Scope Lifetime

auto Local Function execution

register Local Function execution

static Local/Global Entire program

extern Global Entire program

6. Explain recursion. Write a C program to find the factorial of a number using

recursion.

Recursion
Recursion is a programming technique in which a function calls itself to solve a problem. A
recursive solution divides a problem into smaller sub-problems of the same type until a base
condition is reached.

Key Components of Recursion

1. Base condition – Stops the recursive calls
2. Recursive call – Function calling itself with a reduced problem
Without a base condition, recursion leads to infinite calls.

Advantages of Recursion
• Simplifies code for problems like factorial, Fibonacci, and tree traversal
• Improves readability for complex problems
Disadvantage of Recursion
• Uses more memory due to function call stack

C Program: Factorial Using Recursion

#include <stdio.h>

Page 15 of 39
int factorial(int n)
{
if(n == 0)
return 1; // Base condition
else
return n * factorial(n - 1); // Recursive call
}

int main()
{
int num = 5;
printf("Factorial = %d", factorial(num));
return 0;
}

7. Explain string fundamentals in C. Describe different ways of declaring and

initializing strings.

String Fundamentals in C
In C, a string is a sequence of characters stored in a character array and terminated by a
null character ('\0'). The null character indicates the end of the string and is automatically
added by the compiler when a string literal is used.
Example:
char str[] = "C Language";

Important Characteristics of Strings

• Stored in contiguous memory locations
• Last character is always '\0'
• Represented using character arrays or pointers
• Accessed using array indexing or pointers

Page 16 of 39
Ways of Declaring and Initializing Strings
1. Using Character Array with String Literal
char s1[20] = "Hello";
The compiler automatically adds the null character at the end.

2. Using Character Array with Individual Characters

char s2[] = {'H', 'e', 'l', 'l', 'o', '\0'};
The null character must be explicitly included.

3. Declaring Size and Initializing Later

char s3[10];
strcpy(s3, "CSE");
Requires string.h.

4. Using Character Pointer

char *s4 = "Programming";
The pointer points to a string literal stored in read-only memory.

Accessing String Characters

printf("%c", s1[0]); // Access first character

8. Write a C program to perform string operations (length, copy, compare) without

using library functions.
#include <stdio.h>

int main()
{
char s1[50] = "Hello", s2[50], s3[50] = "Hello";
int i, len = 0, flag = 0;

Page 17 of 39
 // Length
for(i = 0; s1[i] != '\0'; i++)
len++;
printf("Length = %d\n", len);

// Copy
for(i = 0; s1[i] != '\0'; i++)
s2[i] = s1[i];
s2[i] = '\0';

// Compare
for(i = 0; s1[i] != '\0'; i++)
{
if(s1[i] != s3[i])
{
flag = 1;
break;
}
}

if(flag == 0)
printf("Strings are equal");
else
printf("Strings are not equal");

return 0;
}

9. Explain string processing using library functions. Describe any four functions from
string.h with examples.

Page 18 of 39
In C, string processing refers to performing operations such as length calculation, copying,
comparison, and concatenation on strings.
C provides a set of predefined string handling functions in the header file string.h, which
make string operations simple, efficient, and reliable.
To use these functions:
#include <string.h>

1. strlen() – String Length

Purpose:
Returns the number of characters in a string, excluding the null character '\0'.
Syntax:
strlen(string);
Example:
char str[] = "Hello";
int len = strlen(str);
printf("%d", len); // Output: 5

2. strcpy() – String Copy

Purpose:
Copies the contents of one string into another string.
Syntax:
strcpy(destination, source);
Example:
char src[] = "C Language";
char dest[20];
strcpy(dest, src);
printf("%s", dest);

3. strcmp() – String Compare

Purpose:
Compares two strings lexicographically.
Return Values:

Page 19 of 39
 • 0 → strings are equal
• < 0 → first string is smaller
• > 0 → first string is greater
Syntax:
strcmp(string1, string2);
Example:
char s1[] = "Data";
char s2[] = "Data";
if(strcmp(s1, s2) == 0)
printf("Strings are equal");

4. strcat() – String Concatenation

Purpose:
Appends one string to the end of another string.
Syntax:
strcat(destination, source);
Example:
char s1[20] = "Hello";
char s2[] = " World";
strcat(s1, s2);
printf("%s", s1);

Advantages of Using Library Functions

• Reduces program complexity
• Saves development time
• Improves readability and reliability
• Optimized for performance

10. Explain the relationship between pointers and strings. Write a C program to access
a string using pointers.

Page 20 of 39
Relationship between Pointers and Strings
In C, a string is stored as a character array terminated by the null character ('\0').
The name of the array itself acts as a pointer to the first character of the string. Therefore,
strings and pointers are closely related.
Key points explaining the relationship:
1. The array name represents the base address of the string.
2. A character pointer can be used to point to a string.
3. String characters can be accessed using pointer arithmetic.
4. Library functions for strings internally use pointers.
5. Strings can be manipulated efficiently using pointers instead of array indexing.
Example:
char str[] = "Hello";
char *p = str;
Here, p points to the first character 'H' of the string.

Accessing String Characters Using Pointers

• *p accesses the current character.
• p++ moves the pointer to the next character.
• Traversal continues until the null character '\0' is encountered.

C Program to Access a String Using Pointers

#include <stdio.h>

int main()
{
char str[] = "C Programming";
char *p = str;

while(*p != '\0')
{
printf("%c", *p);

Page 21 of 39
 p++;
}

return 0;
}
Output
C Programming

Advantages of Using Pointers with Strings

• Faster access to string elements
• Efficient memory usage
• Simplifies string manipulation
• Useful in dynamic memory allocation and function arguments

UNIT-5- 2 marks

1. Define a structure in C. Write the general syntax for declaring a structure.

A structure in C is a user-defined data type that allows grouping of variables of different
data types under a single name.
General syntax:
struct structure_name
{
data_type member1;
data_type member2;
};

2. What is a nested structure? Give a simple example.

A nested structure is a structure that contains another structure as one of its members.
Example:
struct Date

Page 22 of 39
{
int day, month, year;
};

struct Student
{
int roll;
struct Date dob;
};

3. Define an array of structures. Mention one advantage of using it.

An array of structures is a collection of structure variables stored under a single array name.
Example:
struct Student s[50];
Advantage:
It allows efficient storage and processing of multiple records of the same type.

4. What is meant by structures and functions? How are structures passed to functions?
Structures and functions refers to using structures as function arguments or return types.
Structures can be passed to functions:
1. By value
2. By reference (using pointers)
Passing by reference is preferred as it avoids copying the entire structure.

5. Define a self-referential structure. Where is it used?

A self-referential structure is a structure that contains a pointer to the same structure
type.
Example:
struct Node
{
int data;

Page 23 of 39
 struct Node *next;
};
Used in:
Linked lists, trees, and graphs.

6. Differentiate between a structure and a union.

Structure Union

Allocates memory for all members Shares memory among all members

Members can be used simultaneously Only one member used at a time

More memory usage Memory efficient

Keyword: struct Keyword: union

7. What is an enumerated data type? Give an example using enum.

An enumerated data type allows defining a set of named integer constants.
Example:
enum Day {SUN, MON, TUE, WED, THU, FRI, SAT};

8. What is the purpose of the typedef keyword?

The typedef keyword is used to create an alias (new name) for an existing data type.
Example:
typedef int INTEGER;

9. Define bit fields. Mention one advantage of using bit fields.

Bit fields allow storing data in bits instead of bytes within a structure.
Example:
struct status
{
unsigned int flag : 1;
};

Page 24 of 39
Advantage:
Reduces memory usage.

10. What is a data file? List any two file operations in C.

A data file is a collection of data stored permanently on secondary storage.
Two file operations in C:
1. Reading from a file
2. Writing to a file

Unit 5-6 marks

1. Explain structures in C. Describe declaration, initialization, and accessing structure

members with examples.

Structures in C
A structure in C is a user-defined data type that groups variables of different data types
under a single name. Structures are used to represent complex data such as student records,
employee details, and product information.

Declaration of a Structure
A structure is declared using the struct keyword.
struct Student
{
int roll;
float marks;
};
Here, Student is the structure name and roll, marks are structure members.

Initialization of a Structure
Structure variables can be initialized at the time of declaration.
struct Student s1 = {101, 85.5};

Page 25 of 39
Accessing Structure Members
Structure members are accessed using the dot (.) operator.
printf("Roll = %d\n", [Link]);
printf("Marks = %.2f\n", [Link]);

Complete Example Program

#include <stdio.h>

struct Student
{
int roll;
float marks;
};

int main()
{
struct Student s1 = {101, 85.5};
printf("Roll = %d\n", [Link]);
printf("Marks = %.2f\n", [Link]);
return 0;
}

Uses of Structures
• Storing related data of different types
• Organizing complex data efficiently
• Used in arrays, files, and dynamic data structures

2. Explain nested structures and arrays of structures with suitable programs.

Nested Structures

Page 26 of 39
A structure containing another structure as a member is called a nested structure.
struct Date
{
int day, month, year;
};

struct Student
{
int roll;
struct Date dob;
};
Array of Structures
An array of structures stores multiple records of the same structure type.
struct Student s[3];
Program Example
#include <stdio.h>
struct Student
{
int roll;
float marks;
};

int main()
{
struct Student s[2] = {{1, 80.5}, {2, 75.0}};
printf("%d %.2f", s[0].roll, s[0].marks);
return 0;
}

3. Explain how structures are passed to functions. Write a C program illustrating

passing a structure to a function.

Page 27 of 39
Structures can be passed to functions in two ways:
1. Pass by value
2. Pass by reference (using pointers)
Program (Pass by Reference)
#include <stdio.h>

struct Student
{
int roll;
float marks;
};

void display(struct Student *s)

{
printf("%d %.2f", s->roll, s->marks);
}

int main()
{
struct Student s1 = {101, 88.5};
display(&s1);
return 0;
}
Advantage: Passing by reference avoids copying large structures.

4. Describe self-referential structures. Explain their role in implementing linked lists

with an example.
A self-referential structure contains a pointer to the same structure type.
struct Node
{
int data;

Page 28 of 39
 struct Node *next;
};
Role in Linked Lists
• Each node stores data and address of the next node
• Enables dynamic memory allocation
• Used in linked lists, stacks, queues, trees
This structure forms the foundation of dynamic data structures.

5. Explain unions in C. Compare structures and unions with appropriate examples.

Unions in C
A union in C is a user-defined data type in which all members share the same memory
location. At any given time, only one member of the union can store a value. The size of a
union is equal to the size of its largest data member.
Declaration of a Union
union Data
{
int i;
float f;
char c;
};
Initialization and Accessing Union Members
union Data d;
d.i = 10;
printf("%d", d.i);
Only the last assigned member contains a valid value.

Example Program
#include <stdio.h>

union Sample

Page 29 of 39
{
int a;
float b;
};

int main()
{
union Sample s;
s.a = 10;
printf("%d\n", s.a);

s.b = 5.5;
printf("%.2f\n", s.b);

return 0;
}

Comparison between Structure and Union

Structure Union

Allocates separate memory for each member Shares the same memory for all members

All members can be used simultaneously Only one member used at a time

Size is sum of all members Size is size of largest member

More memory usage Memory efficient

Keyword: struct Keyword: union

6. Explain enumerated data types (enum) and the use of the typedef keyword with
suitable examples.

Enumerated Data Types (enum)

Page 30 of 39
An enumerated data type in C is a user-defined data type that consists of a set of named
integer constants. The constants in an enum are assigned integer values automatically,
starting from 0 by default.
Declaration and Example of enum
enum Day
{
MON, TUE, WED, THU, FRI
};
Here:
• MON = 0, TUE = 1, and so on.
• Enum values improve code readability by replacing numbers with meaningful
names.
Usage Example
enum Day d;
d = WED;
printf("%d", d); // Output: 2

typedef Keyword
The typedef keyword is used to create an alias (alternate name) for an existing data type. It
makes complex data types easier to use and improves program readability.
Example of typedef
typedef unsigned int UINT;
UINT x = 10;

Combining enum and typedef

typedef enum
{
RED, GREEN, BLUE
} Color;

Color c = GREEN;
This avoids repeatedly writing the enum keyword.

Page 31 of 39
Advantages
• enum improves readability and reduces errors
• typedef simplifies complex declarations
• Enhances code maintainability

7. Explain bit fields in C. Discuss their advantages and limitations with an example
structure.
Bit Fields in C
Bit fields in C allow storing data in individual bits instead of full bytes within a structure.
They are mainly used when memory efficiency is important, such as in embedded systems
and hardware programming.
Bit fields are declared using a colon (:) followed by the number of bits required.

Declaration and Example Structure

struct Status
{
unsigned int ready : 1;
unsigned int error : 2;
unsigned int mode : 3;
};
In this structure:
• ready uses 1 bit
• error uses 2 bits
• mode uses 3 bits

Accessing Bit Fields

struct Status s;
[Link] = 1;
[Link] = 2;
[Link] = 5;

Page 32 of 39
Advantages of Bit Fields
1. Memory efficient – uses minimum number of bits
2. Useful in hardware control registers
3. Improves performance in memory-constrained systems

Limitations of Bit Fields

1. Platform dependent – behavior may vary across compilers
2. Slower access compared to normal variables
3. Cannot take address of bit-field variables

8. Introduce data files in C. Explain file opening modes and basic file operations.

Data Files in C
A data file in C is a collection of data stored permanently on secondary storage such as a
hard disk. Files are used to store data so that it is not lost when the program terminates.
In C, file handling is done using the FILE structure defined in the header file stdio.h.

File Pointer and Opening a File

To work with a file, a file pointer is used.
FILE *fp;
fp = fopen("[Link]", "r");

File Opening Modes

Mode Description

r Opens file for reading

w Opens file for writing (creates new file)

a Opens file for appending

r+ Opens file for reading and writing

w+ Opens file for reading and writing (overwrites file)

Page 33 of 39
Mode Description

a+ Opens file for reading and appending

Basic File Operations

1. Opening a File
fp = fopen("[Link]", "w");
2. Reading from a File
fgetc(fp);
fgets(str, size, fp);
3. Writing to a File
fputc(ch, fp);
fputs(str, fp);
4. Closing a File
fclose(fp);

Simple Example
FILE *fp;
fp = fopen("[Link]", "w");
fputs("Hello C", fp);
fclose(fp);

Advantages of Using Files

• Permanent data storage
• Data sharing between programs
• Useful for large data handling

9. Explain reading from and writing to text files in C using appropriate functions with
examples.

Text Files in C

Page 34 of 39
A text file stores data in human-readable form using characters. In C, text files are accessed
using file handling functions provided in stdio.h.
To perform any file operation, a file pointer (FILE *) is used.

Writing to a Text File

Writing data to a text file is done using functions such as fputc(), fputs(), and fprintf().
Example: Writing to a File
#include <stdio.h>

int main()
{
FILE *fp;
fp = fopen("[Link]", "w");

fputs("Welcome to C Programming", fp);

fclose(fp);

return 0;
}
Here:
• fopen() opens the file in write mode
• fputs() writes a string to the file
• fclose() closes the file

Reading from a Text File

Reading data from a text file is done using fgetc(), fgets(), and fscanf().
Example: Reading from a File
#include <stdio.h>

int main()
{

Page 35 of 39
 FILE *fp;
char ch;

fp = fopen("[Link]", "r");

while((ch = fgetc(fp)) != EOF)

{
printf("%c", ch);
}

fclose(fp);

return 0;
}
Here:
• fgetc() reads one character at a time
• EOF indicates the end of the file

Common Functions Used for Text Files

Function Purpose

fopen() Opens a file

fclose() Closes a file

fgetc() Reads a character

fputc() Writes a character

fgets() Reads a string

fputs() Writes a string

Advantages of Text Files

• Easy to read and edit

Page 36 of 39
 • Portable across systems
• Useful for storing simple data

10. Analyze random file access in C. Explain the use of fseek(), ftell(), and rewind() with
examples.

Random File Access in C

Random file access allows a program to move the file pointer to any desired position in a
file and read or write data without processing the file sequentially. This improves speed and
flexibility, especially when working with large files.
Random access is mainly used with binary and text files.

File Pointer Movement Functions

1. fseek()
Moves the file pointer to a specified position.
Syntax:
fseek(FILE *fp, long offset, int origin);
Origins:
• SEEK_SET – beginning of file
• SEEK_CUR – current position
• SEEK_END – end of file
Example:
fseek(fp, 10, SEEK_SET);
Moves the pointer 10 bytes from the beginning.

2. ftell()
Returns the current position of the file pointer.
Syntax:
long ftell(FILE *fp);
Example:
long pos = ftell(fp);

Page 37 of 39
printf("%ld", pos);

3. rewind()
Moves the file pointer back to the beginning of the file.
Syntax:
rewind(FILE *fp);
Example:
rewind(fp);

Complete Example Program

#include <stdio.h>

int main()
{
FILE *fp;
fp = fopen("[Link]", "r");

fseek(fp, 5, SEEK_SET);
printf("Position: %ld\n", ftell(fp));

rewind(fp);
printf("Position after rewind: %ld\n", ftell(fp));

fclose(fp);
return 0;
}

Advantages of Random File Access

• Faster access to required data
• Avoids unnecessary reading

Page 38 of 39
 • Suitable for large files

Page 39 of 39