# Unit 5: Structures ## Structures ### Defining a Structure * A **structure** is a user-defined data type that groups together variables of different data types under a single name. * It allows you to create a complex data type that represents a record. ```c struct tag_name { data_type member1; data_type member2; // ... }; ``` * `struct`: Keyword to define a structure. * `tag_name`: Optional name for the structure (can be used to declare variables later). * `member1, member2`: Names of the individual elements within the structure. ### Declaration of Structure Variables * Once a structure is defined, you can declare variables of that structure type. ```c struct tag_name variable_name; ``` * Example: ```c struct Student { char name[50]; int roll_no; float marks; }; struct Student s1; // Declares a variable 's1' of type 'struct Student' ``` ### Accessing Structure Members * Use the **dot operator (`.`)** to access individual members of a structure variable. ```c variable_name.member_name ``` * Example: ```c strcpy(s1.name, "Alice"); s1.roll_no = 101; s1.marks = 85.5; ``` ### Copying and Comparing Structure Variables * **Copying:** You can assign the contents of one structure variable to another if they are of the same type. This copies all members. ```c struct Student s2 = s1; // Copies all members of s1 to s2 ``` * **Comparing:** Structures cannot be directly compared using `==` or `!=` operators. You must compare members individually. ```c if (s1.roll_no == s2.roll_no && strcmp(s1.name, s2.name) == 0) { // Structures are equal } ``` ### Operations on Individual Members * Individual members of a structure can be used in any operation valid for their data type (arithmetic, logical, assignment, etc.). ### Nesting of Structures * A structure can contain another structure as one of its members. This is called **nesting**. ```c struct Address { char street[100]; char city[50]; }; struct Employee { int emp_id; struct Address addr; // Nested structure }; struct Employee e1; strcpy(e1.addr.city, "Mumbai"); // Accessing nested member ``` ### Array of Structures * You can declare an **array** where each element is a structure variable. ```c struct structure_name array_name[size]; ``` * Example: ```c struct Student students[10]; // Array of 10 Student structures students[0].roll_no = 101; // Accessing a member of the first element ``` ## Application of Pointers and Functions on Structures ### Pointers to Structures * A **pointer** can point to a structure variable. * Use the **arrow operator (`->`)** to access members through a pointer to a structure. ```c struct structure_name *pointer_name; pointer_name = &structure_variable; // Accessing members using arrow operator pointer_name->member_name ``` * Example: ```c struct Student *ptr_s; ptr_s = &s1; printf("%d\n", ptr_s->roll_no); // Equivalent to (*ptr_s).roll_no ``` ### Functions and Structures * **Passing Structures to Functions:** * **By Value:** A copy of the entire structure is passed. Changes inside the function do not affect the original structure. * **By Pointer:** The address of the structure is passed. Changes inside the function affect the original structure. This is more efficient for large structures. * **Returning Structures from Functions:** Functions can return a structure variable. ```c // Passing by value void display_student(struct Student s) { // ... } // Passing by pointer void update_marks(struct Student *s, float new_marks) { s->marks = new_marks; } // Returning a structure struct Student create_student(char *name, int id, float mk) { struct Student temp; strcpy(temp.name, name); temp.roll_no = id; temp.marks = mk; return temp; } ``` ## Union ### Defining a Union * A **union** is a user-defined data type that allows **multiple members to share the same memory location**. * Only one member can hold a value at any given time. ```c union union_tag_name { data_type member1; data_type member2; // ... }; ``` ### Declaration of Union Variables ```c union union_tag_name variable_name; ``` * Example: ```c union Data { int i; float f; char str[20]; }; union Data d1; ``` ### Difference Between Structure and Union | Feature | Structure | Union | | :------------ | :---------------------------------------------- | :------------------------------------------------------- | | **Memory** | Allocates **separate memory** for each member. | Allocates **single memory** (size of the largest member) for all members. | | **Access** | All members can hold values simultaneously. | **Only one member** can hold a value at a time. | | **Purpose** | To group related data of different types. | To conserve memory by using the same memory space for different types of data at different times. | | **Declaration** | `struct tag_name { ... };` | `union union_tag_name { ... };` | | **Accessing** | `variable.member` | `variable.member` (but be careful which member is active) | **[Figure: Structure vs. Union Memory Allocation]** This figure illustrates how memory is allocated for structures and unions. It's crucial for understanding the fundamental difference in memory usage, which impacts efficiency and potential pitfalls when using unions. ## Introduction to Static and Dynamic Memory Allocation ### Static Memory Allocation * Memory is allocated at **compile time**. * The size of the allocated memory is **fixed** and known beforehand. * Examples: global variables, static variables, local variables (stack-based). * Managed automatically by the compiler. * Efficient but inflexible if the exact memory requirement is not known at compile time. ### Dynamic Memory Allocation * Memory is allocated at **run time**. * Allows for **flexible memory management** where the size can be determined during program execution. * Typically involves the **heap**. * Requires explicit allocation and deallocation by the programmer. **[Figure: Stack vs. Heap Memory]** This figure visually distinguishes between the stack (used for static allocation of local variables and function calls) and the heap (used for dynamic memory allocation). Understanding this distinction is key to grasping how static and dynamic memory management differ in practice. ### Process of Dynamic Memory Allocation 1. **Request Memory:** Use library functions like `malloc()`, `calloc()`, `realloc()` to request a block of memory from the heap. 2. **Memory Pool:** The operating system manages a pool of free memory. The memory allocation functions search this pool for a suitable block. 3. **Allocation:** If a suitable block is found, it's marked as used and returned to the program as a pointer. 4. **Usage:** The program uses the allocated memory. 5. **Deallocation:** When the memory is no longer needed, use `free()` to return it to the heap, making it available for future allocations. * **Key Functions:** * `malloc(size_t size)`: Allocates a block of `size` bytes. Returns `NULL` on failure. Memory is uninitialized. * `calloc(size_t num_elements, size_t element_size)`: Allocates memory for `num_elements`, each of `element_size` bytes. Initializes memory to zero. Returns `NULL` on failure. * `realloc(void *ptr, size_t new_size)`: Resizes a previously allocated memory block. Can move the block if necessary. * `free(void *ptr)`: Deallocates the memory block pointed to by `ptr`. **[Figure: Dynamic Memory Allocation Process]** This figure outlines the typical steps involved in dynamic memory allocation, from requesting memory using functions like `malloc` to deallocating it with `free`. It highlights the role of the heap and the importance of proper memory management to avoid leaks and errors. --- ## C Programs Based on Concepts ### Structure Example ```c #include #include struct Book { char title[100]; char author[50]; float price; }; int main() { struct Book b1; // Accessing and assigning values strcpy(b1.title, "The C Programming Language"); strcpy(b1.author, "Kernighan & Ritchie"); b1.price = 550.75; // Displaying values printf("Title: %s\n", b1.title); printf("Author: %s\n", b1.author); printf("Price: %.2f\n", b1.price); // Copying structure struct Book b2 = b1; printf("\nCopied Book (b2):\n"); printf("Title: %s\n", b2.title); return 0; } ``` ### Array of Structures Example ```c #include struct Student { int roll_no; char name[50]; }; int main() { struct Student students[3]; // Array of 3 students // Input data for students for (int i = 0; i < 3; i++) { printf("Enter Roll Number for student %d: ", i + 1); scanf("%d", &students[i].roll_no); printf("Enter Name for student %d: ", i + 1); scanf("%s", students[i].name); } // Display data printf("\nStudent Details:\n"); for (int i = 0; i < 3; i++) { printf("Student %d: Roll No: %d, Name: %s\n", i + 1, students[i].roll_no, students[i].name); } return 0; } ``` ### Pointers to Structures Example ```c #include struct Point { int x; int y; }; int main() { struct Point p1 = {10, 20}; struct Point *ptr_p; ptr_p = &p1; // Pointer points to p1 // Accessing members using arrow operator printf("Point coordinates: (%d, %d)\n", ptr_p->x, ptr_p->y); // Modifying members using arrow operator ptr_p->x = 15; printf("Modified Point coordinates: (%d, %d)\n", ptr_p->x, ptr_p->y); return 0; } ``` ### Union Example ```c #include union Message { int code; float value; char message[20]; }; int main() { union Message msg; msg.code = 100; printf("msg.code: %d\n", msg.code); // Now if we access msg.code, it might be corrupted because // we are using the same memory location for float. // The output depends on the system's representation. // printf("Trying to access msg.code after float assignment: %d\n", msg.code); msg.value = 3.14; printf("msg.value: %.2f\n", msg.value); strcpy(msg.message, "Hello Union"); printf("msg.message: %s\n", msg.message); // Accessing other members after message is set will yield garbage // printf("Trying to access msg.code after message assignment: %d\n", msg.code); return 0; } ``` ### Dynamic Memory Allocation (`malloc`) Example ```c #include #include // For malloc and free int main() { int n, i; int *arr; // Pointer to integer printf("Enter number of elements: "); scanf("%d", &n); // Dynamically allocate memory for n integers arr = (int *)malloc(n * sizeof(int)); // Check if memory allocation was successful if (arr == NULL) { printf("Memory allocation failed!\n"); return 1; // Indicate error } // Input elements into the dynamically allocated array printf("Enter %d integers:\n", n); for (i = 0; i < n; i++) { scanf("%d", arr + i); // Equivalent to &arr[i] } // Output elements printf("You entered:\n"); for (i = 0; i < n; i++) { printf("%d ", *(arr + i)); // Equivalent to arr[i] } printf("\n"); // Free the dynamically allocated memory free(arr); arr = NULL; // Good practice to set pointer to NULL after freeing return 0; } ```