4.5 Arrays and Structures

4.5 Arrays and Structures

Introduction to Data Aggregation

Simple variables store single data items. To solve real-world problems, we often need to handle collections of related data. This unit introduces two fundamental composite data types in C: Arrays and Structures. Arrays allow the storage of multiple elements of the same data type in contiguous memory, ideal for lists and matrices. Structures allow the bundling of multiple elements of potentially different data types under a single name, ideal for modeling real-world entities like a student record or a book. Mastering these constructs is crucial for organizing and manipulating complex data efficiently.

---

1. Arrays

1.1 Definition and Concept

1. Definition: An array is a fixed-size, contiguous collection of elements of the same data type. All elements share a common name, and each individual element is accessed by its numerical index (position).

2. Key Characteristics:

   • Homogeneous: All elements must be of the same type (e.g., all int, all float).

   • Contiguous Memory: Elements are stored in consecutive memory locations.

   • Fixed Size: The size (number of elements) must be known at compile time and cannot be changed during runtime in standard C.

   • Random Access: Any element can be accessed directly in constant time using its index.

3. Syntax for Declaration:

   data_type array_name[size];

   • data_type: The type of each element (e.g., int, float, char).

   • array_name: A valid identifier.

   • size: A positive integer constant specifying the number of elements.

   • Example: int marks[50]; declares an array named marks that can hold 50 integers.

1.2 Array Initialization

Arrays can be initialized at the time of declaration.

1. Full Initialization:

   int numbers[5] = {10, 20, 30, 40, 50};

2. Partial Initialization:

   int numbers[5] = {10, 20}; // Elements: [10, 20, 0, 0, 0]

   Remaining elements are automatically set to zero (for numeric types) or NULL (for pointers).

3. Initialization without Specifying Size:

   int numbers[] = {1, 2, 3, 4, 5}; // Compiler deduces size = 5

4. Zero Initialization:

   int arr[100] = {0}; // All 100 elements are set to 0.

1.3 Accessing and Processing Array Elements

1. Indexing: Array elements are accessed using the array name followed by the index in square brackets [].

   • Indexing starts from 0. The first element is array_name[0], the last is array_name[size-1].

   • Example: marks[0] = 95; assigns 95 to the first element.

2. Looping Through an Array: Processing arrays almost always involves loops.

   int i, sum = 0;
   int arr[5] = {5, 10, 15, 20, 25};
   
   // Reading values into an array
   printf("Enter 5 numbers: ");
   for(i = 0; i < 5; i++) {
       scanf("%d", &arr[i]); // Note: & is used for individual element
   }
   
   // Processing (e.g., calculating sum)
   for(i = 0; i < 5; i++) {
       sum += arr[i];
   }
   
   // Printing array elements
   printf("Array elements: ");
   for(i = 0; i < 5; i++) {
       printf("%d ", arr[i]);
   }
   printf("\nSum = %d\n", sum);

1.4 Passing Arrays to Functions

Arrays are passed to functions by reference, not by value. When an array name is used as an argument, what is actually passed is the base address (address of the first element) of the array.

1. Syntax in Function:

   // Function prototype/definition
   return_type function_name(data_type array_name[], int size);
   // OR equivalently using a pointer
   return_type function_name(data_type *array_name, int size);

   • The [] in the parameter indicates an array. The size inside [] can be omitted.

   • Crucially, you must also pass the size of the array as a separate parameter, because the function receiving the array has no built-in way to know its size.

2. Example:

   #include <stdio.h>
   
   // Function to print an array
   void printArray(int arr[], int n) { // 'arr[]' receives the base address
       int i;
       for(i = 0; i < n; i++) {
           printf("%d ", arr[i]);
       }
       printf("\n");
   }
   
   // Function to modify an array (changes persist in main)
   void doubleArray(int arr[], int n) {
       int i;
       for(i = 0; i < n; i++) {
           arr[i] = arr[i] * 2; // Modifies the original array
       }
   }
   
   int main() {
       int myArray[5] = {1, 2, 3, 4, 5};
       
       printf("Original: ");
       printArray(myArray, 5);
       
       doubleArray(myArray, 5); // Passes array name (base address)
       
       printf("Doubled:  ");
       printArray(myArray, 5); // Shows modified values
       
       return 0;
   }
   // Output:
   // Original: 1 2 3 4 5
   // Doubled:  2 4 6 8 10

1.5 Multidimensional Arrays

An array of arrays. The most common is the two-dimensional (2D) array, which can be visualized as a table with rows and columns.

1. Declaration:

   data_type array_name[rows][columns];

   • Example: int matrix[3][4]; declares a 2D array with 3 rows and 4 columns (total 12 integers).

2. Initialization:

   // Method 1: All elements in one brace (row-major order)
   int a[2][3] = {1, 2, 3, 4, 5, 6};
   
   // Method 2: Row-wise initialization (clearer)
   int a[2][3] = { {1, 2, 3},
                   {4, 5, 6} };

3. Accessing Elements: Use two indices: array_name[row_index][column_index].

4. Processing with Nested Loops:

   int i, j, matrix[3][3];
   
   // Input
   for(i = 0; i < 3; i++) {
       for(j = 0; j < 3; j++) {
           printf("Enter element [%d][%d]: ", i, j);
           scanf("%d", &matrix[i][j]);
       }
   }
   
   // Output
   printf("Matrix:\n");
   for(i = 0; i < 3; i++) {
       for(j = 0; j < 3; j++) {
           printf("%d\t", matrix[i][j]);
       }
       printf("\n");
   }

5. Passing to Functions: Similar to 1D arrays, but the number of columns must be specified.

   void printMatrix(int mat[][4], int rows) { // Columns (4) must be specified
       // ... nested loops ...
   }

---

2. Structures

2.1 Definition and Concept

1. Definition: A structure (struct) is a user-defined data type that groups together variables of different data types under a single name. These variables are called members.

2. Purpose: To represent a real-world entity that has multiple attributes. (e.g., a Student has roll_no, name, marks).

3. Syntax for Declaration:

   struct structure_tag {
       data_type member1;
       data_type member2;
       // ... more members
   };

   • Note the semicolon (;) after the closing brace.

   • Example:

     struct Student {
         int roll_no;
         char name[50];
         float marks;
     };

     This defines a new type called struct Student. No memory is allocated yet.

2.2 Structure Variable Declaration and Initialization

1. Declaring Structure Variables:

   // Method 1: Declare after structure definition
   struct Student {
       int roll;
       char name[30];
   };
   struct Student s1, s2; // s1 and s2 are variables of type struct Student
   
   // Method 2: Declare during structure definition
   struct Point {
       int x;
       int y;
   } p1, p2; // p1 and p2 are variables declared here

2. Initializing Structure Variables:

   // At declaration
   struct Student s1 = {101, "Alice", 85.5};
   
   // Designated Initialization (C99 onwards) - order doesn't matter
   struct Student s2 = {.name = "Bob", .roll = 102, .marks = 90.0};
   
   // Member-wise assignment after declaration
   struct Student s3;
   s3.roll = 103;
   strcpy(s3.name, "Charlie"); // For string, use strcpy
   s3.marks = 77.5;

2.3 Accessing Structure Members

Members of a structure variable are accessed using the dot (.) operator.

struct Student s1 = {101, "Alice", 85.5};

// Accessing members for reading/writing
printf("Roll: %d\n", s1.roll);
printf("Name: %s\n", s1.name);

s1.marks = 88.0; // Modifying a member

2.4 Array of Structures

One of the most powerful combinations: an array where each element is a structure. Ideal for storing records of multiple entities.

#include <stdio.h>
#include <string.h>

struct Student {
    int roll;
    char name[30];
    float marks;
};

int main() {
    // Declare and initialize an array of 3 students
    struct Student class[3] = {
        {1, "Alice", 85.5},
        {2, "Bob", 92.0},
        {3, "Charlie", 78.5}
    };
    
    // Accessing elements
    printf("Student 2 Name: %s\n", class[1].name); // Output: Bob
    
    // Processing with a loop
    int i;
    float total = 0;
    for(i = 0; i < 3; i++) {
        printf("Roll: %d, Name: %s, Marks: %.1f\n", 
               class[i].roll, class[i].name, class[i].marks);
        total += class[i].marks;
    }
    printf("Average Marks: %.2f\n", total / 3);
    
    return 0;
}

2.5 Pointers to Structures

A pointer can point to a structure variable. This is efficient for passing large structures to functions (avoids copying the entire structure) and for dynamic memory allocation.

1. Declaring a Structure Pointer:

   struct Student *ptr;
   struct Student s1;
   ptr = &s1; // Pointer now points to s1

2. Accessing Members via Pointer:

   • Using the arrow operator (->) is the standard and cleaner method.

   • Using the dereference and dot operator (*ptr).member is equivalent but less common.

   struct Student s1 = {101, "Alice", 85.5};
   struct Student *ptr = &s1;
   
   // Access using arrow operator (Preferred)
   printf("Roll (via ->): %d\n", ptr->roll);
   printf("Name (via ->): %s\n", ptr->name);
   
   // Access using dereference and dot (Equivalent)
   printf("Roll (via *.): %d\n", (*ptr).roll);
   
   // Modifying via pointer
   ptr->marks = 90.0; // Changes s1.marks

3. Passing Structure Pointers to Functions (Call by Reference for Structures):

   #include <stdio.h>
   
   struct Distance {
       int feet;
       float inches;
   };
   
   // Function takes a pointer to struct
   void addInches(struct Distance *d, float add) {
       d->inches += add; // Directly modifies the original structure
       if(d->inches >= 12.0) {
           d->feet += (int)(d->inches / 12);
           d->inches = fmod(d->inches, 12.0);
       }
   }
   
   int main() {
       struct Distance d1 = {5, 9.5};
       printf("Before: %d feet %.1f inches\n", d1.feet, d1.inches);
       
       addInches(&d1, 5.0); // Pass address of structure
       
       printf("After:  %d feet %.1f inches\n", d1.feet, d1.inches);
       return 0;
   }

2.6 Nested Structures

A structure can have another structure as a member.

struct Date {
    int day;
    int month;
    int year;
};

struct Employee {
    int id;
    char name[50];
    struct Date joining_date; // Nested structure
    float salary;
};

int main() {
    struct Employee emp1 = {1001, "John", {15, 5, 2020}, 50000.50};
    
    // Accessing nested members
    printf("Joining Year: %d\n", emp1.joining_date.year);
    
    return 0;
}

2.7 Typedef with Structures

The typedef keyword creates an alias (a new name) for a data type, which can simplify structure declarations.

// Method 1: Define structure and typedef separately
struct Student_ {
    int roll;
    char name[30];
};
typedef struct Student_ Student; // 'Student' is now an alias for 'struct Student_'

// Method 2: Combine definition and typedef (Most common)
typedef struct {
    int roll;
    char name[30];
    float marks;
} Student; // 'Student' is the new type name

// Usage
Student s1, s2; // No need to write 'struct' keyword
Student *ptr;

---

3. Comparison: Arrays vs Structures

Feature	Array	Structure (struct)
Data Type	Homogeneous (all elements same type)	Heterogeneous (members can be different types)
Element Access	By numeric index (arr[0])	By member name (student.roll)
Memory Allocation	Contiguous for all elements	Contiguous, but may have padding between members
Size	Fixed at compile time	Fixed at compile time (sum of member sizes + padding)
Purpose	Store a collection of similar items (list)	Store a collection of related but different attributes of an entity (record)
Passing to Func.	By reference (base address)	Can be by value (copies entire struct) or by reference (using pointer)

Conclusion: Arrays provide powerful, efficient storage for sequences of uniform data, while structures offer the flexibility to model complex, composite data types. Combining them—through arrays of structures or structures containing arrays—allows programmers to build sophisticated data models that closely mirror real-world information, forming the backbone of many applications, from simple record-keeping systems to complex database representations.