CS 36: File Processing Study Guide

Questions and Answers

Which of these functions are used for file processing?

fscanf() (correct)

delete()

fopen() (correct)

fclose() (correct)

The function `fread()` is commonly used to format data into a file.

False

What is the purpose of the `fopen()` function?

To open a file.

The `fseek()` function is used to ____ within a file.

move the file pointer to a specific location. Signup and view all the answers

Match the following data structures with their operations:

Stack = push() and pop() Queue = enqueue() and dequeue() Linked List = inserting and deleting elements Array = fixed size and faster access Signup and view all the answers

Which modes are used to open files in binary?

'wb+' Signup and view all the answers

What is a singly linked list?

A data structure where each node contains a value and a reference to the next node. Signup and view all the answers

A queue follows the Last In, First Out (LIFO) principle.

False Signup and view all the answers

A ____ is used to manage start pointers in data structures.

struct Signup and view all the answers

What are the primary reasons for using interface and implementation files?

All of the above Signup and view all the answers

What does the `feof()` function check?

It checks if the end of the file has been reached. Signup and view all the answers

Study Notes

File Processing

Common file processing functions include fopen(), fprintf(), fseek(), fscanf(), fwrite(), fclose(), feof(), and rewind().
File access modes should be understood; for instance, "wb+" indicates random access in binary mode, where 'b' denotes binary.
Key differences exist between sequential and random-access file methods.

Data Structures

Linked Lists: Nodes contain values and references to the next node.
- Inserting Elements: Add a new node to the list.
- Deleting Elements: Remove nodes while updating references to maintain connectivity.
Stack: Implements Last In, First Out (LIFO) principle.
- push(): Adds an element to the top of the stack.
- pop(): Removes the top element of the stack.
Queue: Follows First In, First Out (FIFO) principle.
- enqueue(): Adds an element to the end of the queue, maintaining a tail pointer.
- dequeue(): Removes the front element from the queue.
Start Pointers: Using a struct to hold the start pointer can manage elements and track the tail pointer in queues effectively.
Comparison of types of linked lists versus arrays demonstrates flexibility in node-based structures.

Header Files

Interface and implementation files serve three primary purposes: separate implementation details from interface, promote code reuse, and provide clearer organization.
Include Guard: Prevents multiple inclusions of the same header file.
Interface File:
- Contains function prototypes for use in various modules.
Implementation File:
- Provides definitions of functions and user data types, detailing how the code works.

File Functions Explained

fopen(): Opens a specified file and returns a file pointer. It is essential for memory loading and setting the initial character pointer. Modes include:
- "r": Open for reading; file must exist.
- "w": Open for writing; if the file exists, it's overwritten; if not, a new file is created.
- "a": Open for appending data to an existing file.
- "rb", "wb", "ab": Binary modes for respective operations.
fseek(): Moves the file pointer within a file to a specific location based on offset and whence options (e.g., SEEK_SET, SEEK_CUR, SEEK_END).
fwrite(): Writes data to a file with a specified size, count, and stream pointer.
feof(): Checks if the end of the file has been reached, returning a nonzero value if true.
fprintf(): Writes formatted output to a file.
fscanf(): Reads formatted input from a file.
fclose(): Closes an opened file, which also frees resources.
rewind(): Resets the file pointer to the beginning of the file.### Stack Operations
Push: Inserts an element at the top of a stack.
Example: push(s) adds the element 5 to the top of the stack.
Pop: Removes and returns an element from the top of the stack.
Follows the Last In, First Out (LIFO) principle.

Queue Operations

Queue Principle: Follows First In, First Out (FIFO); elements are enqueued at the end and dequeued from the start.
Enqueue: Inserts an element at the end of the queue.
Example: enqueue(5) adds the element 5 to the end of the queue.
Dequeue: Removes and returns the front element of the queue.

Starting Pointers

Used in various data structures to track the starting point or head of the structure.
Structs can manage start pointers along with additional information like a counter for element count or a tail pointer for queues.

Types of Linked Lists

Singly Linked List: Each node contains a value and a reference to the next node.
Doubly Linked List: Each node contains a value, a reference to the next node, and a reference to the previous node.
Circular Linked List: The last node references the first node, forming a circle.

Comparison: Linked Lists vs. Arrays

Linked Lists:
- Dynamic size allows for flexible handling of data.
- Easy insertion and deletion of elements without the need to shift others.
- More memory usage because of the storage of references.
Arrays:
- Fixed size restricts flexibility.
- Faster access to elements via indexing.
- Insertion and deletion can be expensive due to possible shifting of elements.