Structures, unions and file handling notes — Unit 5

Arrays can only hold elements of the same data type. What if we want to store information about a Student? We need a name (string), roll number (int), and marks (float). A Structure allows us to group different data types under a single name.

struct Student {
    char name[50];
    int roll;
    float marks;
}; // Semicolon is mandatory here!

int main() {
    struct Student s1 = {"Alice", 101, 89.5};
    printf("Name: %s", s1.name); // Using the dot operator
    return 0;
}

If we need to store data for 60 students, creating 60 individual variables (s1, s2, ...) is impractical. Instead, we create an array where each element is a structure.

struct Student class[60]; // Array of 60 students

// Accessing the 5th student's marks
class[4].marks = 95.0;

We can have pointers pointing to structures. When accessing members through a pointer, we must use the arrow operator (`->`) instead of the dot operator (`.`).

struct Student s1 = {"Bob", 102, 75.5};
struct Student *ptr = &s1;

// These two statements do the exact same thing:
printf("%d", s1.roll);
printf("%d", ptr->roll);

A Union is similar to a structure, but it uses the same memory location for all its members. This means a union can only hold ONE of its members' values at any given time.

⇒Typedef

`typedef` is used to give a new name (alias) to an existing data type. It is often used with structures to avoid typing 'struct' repeatedly.

typedef struct {
    int x, y;
} Point;

Point p1; // No need to write 'struct Point p1'

⇒Enumerations (Enum)

`enum` is a user-defined type consisting of named integer constants.

enum Day { SUN, MON, TUE, WED, THU, FRI, SAT };
// SUN = 0, MON = 1, etc.

Variables exist in RAM, which is volatile. When the program ends, the data is lost. File handling allows us to store data permanently on the hard drive.

• FILE pointer: A special pointer used to communicate with the file.
• Opening a file: fopen()
• Closing a file: fclose() - Always close files to prevent data corruption!

FILE *fptr;
fptr = fopen("data.txt", "r"); // Open for reading

if(fptr == NULL) {
    printf("Error opening file");
    return 1;
}

fclose(fptr);

⇒Writing to a file (fprintf / fputs)

FILE *fptr = fopen("file.txt", "w");
fprintf(fptr, "Hello %s", "World"); // Formatted write
fputs("\nNew line", fptr); // String write

⇒Reading from a file (fscanf / fgets)

char buffer[100];
FILE *fptr = fopen("file.txt", "r");

// Read one word at a time
fscanf(fptr, "%s", buffer);

// Read a whole line (safest way)
fgets(buffer, sizeof(buffer), fptr);

⇒Binary I/O (fread / fwrite)

Used primarily for reading/writing arrays or structures directly to disk in raw memory format.

struct Student s1 = {"Alice", 1, 90};
FILE *fp = fopen("data.bin", "wb");
fwrite(&s1, sizeof(struct Student), 1, fp);

⇒End of File (EOF)

When reading a file, we often want to read until the end. `feof(file_pointer)` returns true if we hit the end. Alternatively, `fscanf` returns `EOF`.

⇒Unit 5 Mastery

• Can you write the syntax for a `struct` and access it with both `.` and `->`?
• Do you know the memory differences between a Structure and a Union?
• Can you list the common file modes (`r`, `w`, `a`)?
• Can you write a program to open a file, write a string to it, and close it safely?
• Do you understand the difference between text files and binary files?